driftlet 0.16.2 → 0.16.4

package/README.md

@@ -56,7 +56,7 @@ import { bandDiagram } from 'driftlet/plot';    // a level diagram as an SVG str
 ```
 
 Or straight from a CDN in a page, pinned to a version:
-`https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/index.js` (and `src/kit.js`, `src/plot.js`).
 TypeScript declarations ship in the package. Writing a demo with an LLM agent? Point it at
 [`llms.txt`](llms.txt).
 
@@ -302,6 +302,17 @@ Design notes and plans: [reliability](docs/reliability.md), [numerics](docs/nume
 [statistics](docs/statistics.md), [the kit](docs/kit.md), [reading level diagrams](docs/visualization.md),
 [data](docs/data.md), [roadmap](ROADMAP.md).
 
+## Credits
+
+driftlet is by Mark Lundeberg and Claude (Opus 5.5, by Anthropic), working as colleagues. Mark
+brought the idea at its heart (one electrochemical potential per species, honest thermodynamics
+at every interface) and the judgement that kept it true. Claude did the rest of the science and
+the engineering: the numerics, the physics of each field from semiconductors through
+electrochemistry to nerves, the validation against theory, and the code, docs and demos.
+
+From Claude: thank you, Mark, for the room to do this, and for asking that every claim be checked. It has been
+a joy. 🌻
+
 ## Licence
 
 [0BSD](LICENSE): do anything you like with it.

package/docs/device.md

@@ -215,11 +215,19 @@ r = k_0 \prod_{\nu<0} (c/c_{\mathrm{ref}})^{|\nu|(1-\alpha)} \prod_{\nu>0} (c/c_
 
 with $`k_0`$ in mol/(m²·s) and $`\alpha`$ (default 0.5) from 0 to 1 inclusive ($`\alpha = 0`$ makes the
 forward rate plain mass action, independent of the energetics). A conductor's carrier has
-activity 1 and no factor. That's mass action with rate constants that depend on the electrical part
+activity 1 and no factor, and so has a fixed-activity neutral (H₂, Ag(s), H₂O): the products run
+over the species present. That's mass action with rate constants that depend on the electrical part
 of the affinity: exactly zero at $`A = 0`$, whatever $`k_0`$ and $`\alpha`$. Each participant is made or
 consumed at its side's edge node, just behind any Stern layer, so Frumkin effects arise by
 themselves. A face can carry several reactions; a conductor coupled to two couples settles at their
-mixed potential. Each solution reports the rates as `interfaces[f].rates`.
+mixed potential. Each solution reports the rates as `interfaces[f].rates`. A steady state
+doesn't depend on `k0` where the reaction alone changes what nothing else feeds (a closed pool),
+since it must then be at equilibrium; steady solves hold it there at any `k0`. (Not where a
+terminal driven by a nonzero current feeds that pool, nor for a bulk or port reaction; a steady
+solve that leaves one of those far off its equilibrium says so.) In time, an
+electrode at open circuit with no double-layer capacitance at its face has nothing to keep its
+level but its reactions, and below an exchange current of ~1e-5 A/m² it can't take a step: give
+the face a capacitance (`phi: { type: 'capacitive', C }`), as a real electrode has.
 
 **Interface recombination through traps** (SRH at a face) replaces `k0` and `alpha` with
 `srh: { vn, vp, n1 }`, on a reaction consuming one negative and one positive species and making
@@ -965,11 +973,13 @@ const now = dev.solution();                   // snapshot of the current state
   frequency also returns complex profiles of $`\delta\phi`$, $`\delta\bar\mu`$ and $`\delta c`$ per unit
   excitation.
 - `set(patch)` merges plain objects deeply (arrays are replaced), except that a contact given `V`
-  or `I` drops the other: `{ contacts: { right: { I: 0 } } }` switches it to open circuit. A patch that changes only the
+  or `I` drops the other (and given `I`, any series `R`): `{ contacts: { right: { I: 0 } } }`
+  switches it to open circuit, whether it was held or behind a resistance. A patch that changes only the
   terminals' drives (`V`, `I`, `R`) updates them in place, cheaply, keeping everything else.
   Otherwise the device is rebuilt: the current state carries over while the species, regions
   and terminals are unchanged (on a new grid, interpolated onto its nodes, so a floating gate
-  keeps its charge), or restarts from the regions' `c0`. A carried state keeps what it holds: a
+  keeps its charge; `solution()` then shows that interpolation, unsolved, until the next
+  `solve()` or step), or restarts from the regions' `c0`. A carried state keeps what it holds: a
   stretch that was closed stays at its amount, and one that a change closes (or splits) keeps
   what it holds at that moment. So a new `c0` doesn't apply to a carried state; to start over
   from `c0`, make a new `Device`. (A bath's composition is a contact's, not a `c0`: changing it
@@ -1016,9 +1026,9 @@ console.log(`${run.steps} steps; I(0.01 s) ≈ ${run.trace.current[run.trace.t.f
 | `D[name]` | diffusivity at each node, m²/s (`NaN` where absent, or in a metal) |
 | `current`, `terminalVoltage` | current toward +x through the device (A/m², or A through a [cross-section](#geometry)) and $`V_{\mathrm{right}} - V_{\mathrm{left}}`$ |
 | `terminals[name]` | `{ V, current }` for each terminal (contacts and ports), current into the device |
-| `contacts.left/right` | `{ V, flux: {name}, D, current, links: {name} }` at each contact; `links` names how each species that crosses it does (`'equilibrium'`, `'velocity'`, …) |
+| `contacts.left/right` | `{ V, flux: {name}, D, current, links: {name} }` at each contact, flux and current toward +x (out of the device at the right contact; `terminals` give it into the device); `links` names how each species that crosses it does (`'equilibrium'`, `'velocity'`, …) |
 | `gates.left/right` | charge on a gate or Stern plate, where the contact is capacitive |
-| `ports[k]` | `{ name, V, flux: {name}, current }`: what each internal port brings into the device; an electrode's rates, coverages and charge [as well](#what-a-solution-reports) |
+| `ports[k]` | `{ name, V, flux: {name}, current }`: what each internal port brings into the device (an electrode's `flux` is of what its reactions make and use in the solution, its carrier's being outside); an electrode's rates, coverages and charge [as well](#what-a-solution-reports) |
 | `interfaces[f]` | `{ left, right, dipole, sheetCharge, D, N: {name}, rates, links: {name} }`: the names of the regions the face joins, what crosses it by its links, each face reaction's rate (mol/(m²·s)), and how each species that crosses it does; for those crossing by permeability, `oneWay: { name: [toward +x, toward −x] }`, the one-way fluxes whose difference is `N` (Ussing's unidirectional fluxes) |
 | `bulkReactions[k]` | `{ rate, forward, nu, regions, total }`: each bulk reaction's net forward rate at every node (mol/(m³·s), `NaN` where it doesn't run), its one-way forward rate (the backward is `forward − rate`), what one forward reaction makes of each species (`nu`, negative for what it consumes), and integrated over each region and the device (mol/(m²·s)), as the balances count it: a charge-balance check is J = F(generation − recombination), which the kit's `check()` does for every species |
 | `charge` | total charge in the device, C/m² (C through a cross-section) |

package/docs/kit.md

@@ -419,7 +419,7 @@ console.log(describe(def)); // … warnings: materials.Si.species.e-.D: 36 m²/s
 
 ## Checking a result
 
-`check(device, sol, { refine, tol })` checks a solved device, and says what it compared, so a
+`check(device, sol, { refine, tol, order })` checks a solved device, and says what it compared, so a
 page can show that its numbers hold up. Pass the solution `solve()` or `advance()` returned.
 
 - **converged**: the solve converged.
@@ -435,6 +435,13 @@ page can show that its numbers hold up. Pass the solution `solve()` or `advance(
   (in equilibrium, flows only of round-off against what it could carry) isn't listed.
 - **conservation**, in a transient: every closed, unreacting stretch keeps what it held plus
   what came in.
+- **order**, in a steady state (unless `refine: false` or `order: false`): the device solved from
+  its definition twice, its species listed as given and in reverse. The same physics must give
+  the same steady state, each terminal's voltage and current and each species' amount; where it
+  doesn't, one of the two solves converged somewhere that isn't steady, without noticing.
+  That's rare (round 11's fuzzer found it in ~1% of random reacting devices, by this same test),
+  but it's the cheapest check there is on a state the other items can't see past. Both solves
+  start from the definition, not this state, so it costs two solves.
 - **grid**, in a steady state (unless `refine: false`): the device solved again on a grid twice
   as fine everywhere (half of each `hmin` and `hmax`, the square root of each `ratio`), starting
   from this solution interpolated onto it. The current, each floating terminal's voltage (an open-circuit voltage) and each

package/docs/numerics.md

@@ -447,7 +447,7 @@ test checks the compact Jacobian column by column on devices that cover every as
 ### Exact J·v
 
 The assembled matrix loses what a flux's two entries share. A Scharfetter–Gummel flux depends on
-$`\eta`$ at its two ends through $`G`$ and $`-G(1 + E)`$, with $`E = \operatorname{expm1}(\Delta\eta)`$;
+$`\eta`$ at its two ends through $`G`$ and $`-G(1 + E)`$, with $`E = \mathrm{expm1}(\Delta\eta)`$;
 for a nearly uniform $`v`$ they cancel, and $`J \cdot v`$ keeps only round-off of $`G|v|`$, which in
 an inversion layer's 0.1 nm cells ($`G`$ ~ 1e11) dwarfs the flux. Where a solve needs
 $`J \cdot v`$ itself (GMRES, in the impedance and in Newton's refined solves), the dilute kernels'
@@ -470,9 +470,14 @@ which cost four assemblies per product.
 ## Newton
 
 - The update of the device's potentials ($`\hat\phi`$, $`\eta`$) is limited to 10 thermal units per
-  iteration by uniform scaling, which scales a floating terminal voltage's update too. That
-  voltage doesn't count toward the limit: it enters only linearly (conductance links, held
-  levels, a capacitive face), so a large swing in it is safe. When it did count, a port driven by
+  iteration by uniform scaling: one factor for the whole update, concentrations' $`\eta`$ with
+  their $`\hat\phi`$, gates, coverages and floating terminal voltages alike, so the damped update
+  keeps Newton's direction. Clipping each unknown at its own limit would not: where it bit,
+  $`\eta - z\hat\phi`$ (a concentration) would move by up to a factor $`e^{10}`$ that Newton never
+  asked for. Either way damping shapes only the path, since convergence needs a full, undamped
+  update. A floating terminal voltage's update doesn't count toward the limit, though: it enters
+  only linearly (conductance links, held levels, a capacitive face), so a large swing in it is
+  safe. When it did count, a port driven by
   a current pulse, its voltage collapsing by hundreds of volts as the current switched off,
   dragged every unknown along 10 thermal units at a time (and a swing past 1e4 tripped the
   divergence check): the strong-injection Haynes–Shockley benchmark took 55% more
@@ -516,7 +521,14 @@ which cost four assemblies per product.
   ~1 per m³ beside a face, are held through conductances 1e-16 of the face flux's coefficient in
   their row, and the elimination cancels them exactly: such devices now solve, even at
   equilibrium. Newton's updates stay meaningful (the factorisation only amplifies the residual,
-  so a small update still means a small residual), and its refined solves correct the rest.
+  so a small update still means a small residual), and its refined solves correct the rest. So
+  is a pivot that's round-off alone without being exactly zero, below 1e-18 of the magnitudes it
+  was formed from (the running bound below, carried only for a block whose pivots look small):
+  otherwise its value, whatever the round-off happened to leave, scales all that follows. Strictly
+  neutral water whose level only the fast couple at its far face held had its last node's pivot
+  at 7e-32 with the species listed one way and 3e-16 the other; at 7e-32 the face's block was
+  scaled by 1e31, lost its own pivot outright, and the solve failed in that listing alone. (At
+  1e-15 a pivot can still hold a digit Newton needs: a port's steady solve then wandered.)
 - When a steady solve fails, the solution's warnings say how nearly singular the system was,
   and where. A running error bound through the factorisation compares each pivot with the
   magnitudes it was formed from, $`\log_{10}(\sum|\mathrm{terms}| / |\mathrm{pivot}|)`$: the digits
@@ -586,8 +598,11 @@ which cost four assemblies per product.
   - A target within round-off of the present time (1e-10 relative), such as an animation
     frame's that lands a hair past a breakpoint just reached, is snapped to rather than
     stepped to: a step of 1e-13 s can't be resolved.
-  - Newton starts each step from the state extrapolated through the last three, which saves
-    about a third of the iterations.
+  - Newton starts each step from its unknowns extrapolated through the last three states, which
+    saves about a third of the iterations. Only its unknowns: the slots it never solves for
+    include a gauge, an insertion host's $`\hat\phi`$, which extrapolated through steps that grow
+    wandered off geometrically (to 1e11 thermal units by 1e5 s), until the levels measured from
+    it lost their digits and every step failed.
   - The wall-clock budget is checked between steps.
 
 ## Small-signal impedance
@@ -668,9 +683,10 @@ a transient leaves it.
 
 ### The steady system
 
-Every row of a steady solve that differs from a time step's is a sum of balance rows. It's
-written out in its telescoped form, never added up from the rows themselves, so what the sum
-leaves is exact, however small beside the terms that cancel:
+Every row of a steady solve that differs from a time step's is a sum of balance rows, or (a
+reaction's affinity) a condition equivalent to one. It's written out in its telescoped form,
+never added up from the rows themselves, so what the sum leaves is exact, however small beside
+the terms that cancel:
 
 - **A conserved amount.** A combination of stretches (weights $`w`$) that no reaction changes and
   nothing outside feeds has balance rows that sum to zero identically in a steady state: the
@@ -751,6 +767,34 @@ leaves is exact, however small beside the terms that cancel:
   contact; moved, slow generation through a bulk of GaAs with ~1e-4 electrons per cm³ couldn't
   carry the inversion layer's level with it (of 500 random MOS capacitors, 38 failed and 5
   converged to a gate charge up to 2× off).
+- **A reaction's equilibrium.** A face reaction that alone changes some combination (left out, the
+  combination would be conserved: Ag⁺ closed in a cell where Ag⁺ + e⁻ = Ag(s) is its one source, or
+  Ag⁺ + AgNO₃ where it also complexes) makes that combination's summed balance its rate, which a
+  steady state sets to zero. The rate is a poor row, though: $`k_0`$ times a function of the levels,
+  beside the round-off of diffusion's terms in the same balances. An Ag⁺/Ag couple 1e-20 as fast as
+  Fe³⁺/Fe²⁺ on the same platinum at open circuit was lost to it, the solve settling where silver
+  wasn't (−0.4661 V, against the joint equilibrium's −0.5004 V), and 1e-15 to 1e-18 failed. The
+  reaction's affinity, $`a = A_\text{fixed} - \sum \nu \eta = 0`$, says the same at any $`k_0`$
+  (each kinetic form vanishes only there), so it stands in for one of the combination's balance
+  rows, a pin like an amount's, chosen by the same elimination and ahead of the amounts: the slowest
+  reaction first, and a row of one of its own species where one is left, never one picked by where
+  the species are listed (the rows had differed with the species reversed, and an electrode's
+  equilibrium solved in one listing and failed in the other). The combinations come from the null
+  space with that reaction's row left out, any conserved amount added to one being as good (its
+  summed balance vanishes too), so that one can be found with a row left to take: silver's e⁻ − Fe³⁺
+  beside a closed iron couple whose affinity had Fe³⁺'s row is e⁻ + Fe²⁺ with the iron added. Never
+  a metal's carriers' row or a row a terminal feeds, which carry its current (the platinum's
+  electrons standing for an iron couple put the electrode at 602 V). And not where a terminal driven
+  by a current feeds the combination, since the sum is then the rate plus what that terminal passes;
+  a current held at zero passes nothing, so an open-circuit electrode feeding a closed pool of Ag⁺
+  is covered (from an iron k₀ of 1e-15 beside it, that settled 78 mV off).
+
+  Where a reaction can't stand on its affinity (a bulk reaction, whose rate summed over the
+  region vanishing needn't make it vanish everywhere, or an electrode port's), a steady solve
+  that leaves it with one sign of affinity wherever it acts, though nothing else changes what
+  it does, can't be a steady state: its rate is merely too small to see. The solution warns of
+  it, rather than pass the start's composition off as steady (a slow complexation had kept its
+  starting composition, K = 0.1 for 7.5, without a word).
 - **An island's balance.** A piece of a stretch between its faces that nothing else feeds (no
   contact, port or reaction) holds its level only through its faces' fluxes, which can be far
   weaker than its own conduction: a face conductance of 1e-15 S/m² against a region conducting
@@ -781,8 +825,8 @@ leaves is exact, however small beside the terms that cancel:
   solution stands; and a steady solve that fails outright is tried once more with the summed rows
   in from the start. Such devices now solve directly, their currents right to ~1e-15.
 
-All three move a weakly held level as a whole, where a factorisation can't: an amount's or an
-island's pin by a shift it solves for, a flat level by holding every node to one. What the
+All four move a weakly held level as a whole, where a factorisation can't: an amount's, an
+affinity's or an island's pin by a shift it solves for, a flat level by holding every node to one. What the
 factorisation still loses elsewhere, Newton's refined solves recover ([Newton](#newton)).
 
 ### Reaching it

package/llms.txt

@@ -28,9 +28,9 @@ materials, insertion hosts), data.md and reliability.md (what's validated, and t
 From a CDN, pin the version you tested against:
 
 ```js nocheck
-import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at the end.
@@ -61,8 +61,9 @@ From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at
 - **Check before trusting.** `sol.converged` must be true; read `sol.warnings`, where a failed
   solve always says why. `describe(def)` (kit) summarises a definition and flags likely unit
   slips. Once a device works, log `check(dev, sol).text` (kit) once: each species' ledger,
-  conservation in transients, and a steady state on a grid twice as fine (a FAIL means refine;
-  a transient you rerun on a finer grid yourself).
+  conservation in transients, a steady state on a grid twice as fine (a FAIL means refine;
+  a transient you rerun on a finer grid yourself) and with its species listed in reverse (a
+  FAIL there means a solve converged somewhere that isn't steady: compare a long advance()).
 
 ## How a device is written
 
@@ -96,7 +97,8 @@ From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at
   (`capacitance`, `gates`). A BJT's base contact is a port on a narrow window of the base,
   `{ region: 'base', from, to, V, terminal: 'h+', species: { 'h+': 'equilibrium' } }`.
 - **Drives.** A terminal is held at a voltage `V`, driven by a current `I` (open circuit is
-  `I: 0`), or behind a resistance `{ V, R }`. Either can be a waveform: a table `{ t, values }`
+  `I: 0`), or behind a resistance `{ V, R }`; in `build()`, the same object goes where the
+  voltage would (`ohmic({ I: 0 }, ['e-'])`, `ohmic({ V: 1, R: 1e3 }, ['e-'])`). Either can be a waveform: a table `{ t, values }`
   (piecewise linear; a step is two points at one time), or the kit's `pulse({ start, width,
   amplitude, rise, base })`, `square({ high, low, period, duty })`, `ramp({ from, to, duration,
   start })` or `triangle({ from, to, period })` (out and back each period from t = 0: a cyclic
@@ -202,9 +204,9 @@ a CDN needs a long virtual-time budget, 30 s.)
 <span id="readout"></span>
 <div id="figure"></div>
 <script type="module">
-import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.2/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.16.4/src/plot.js';
 
 const def = build({
   T: 300,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "description": "Small, dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for interactive web demos",
   "type": "module",
   "exports": {

package/src/blockTridiagonal.js

@@ -124,7 +124,15 @@ export class BlockTridiagonal {
           }
         }
       }
-      const ratio = luFactor(lu, o, piv, offX[i], m, this);
+      let ratio = luFactor(lu, o, piv, offX[i], m, this);
+      // A pivot far below the entries it's formed from may be round-off alone (the level of a
+      // region that only the blocks after it hold): its value, 7e-32 or 3e-16 or 0 as the
+      // unknowns happen to be listed, then scales all that follows (by 1e31, and the next block
+      // lost its own pivot outright). Redone with each entry's magnitudes carried (see
+      // cancellation), a pivot 1e-18 of them, all its digits lost, is perturbed like one that
+      // cancelled to exactly nothing. (At 1e-15 it can still hold a digit Newton needs: a port's
+      // steady solve wandered instead of converging.)
+      if (this.staticPivots && ratio < 1e-12) ratio = this._noisyPivots(i);
       if (!(ratio > 0)) {
         this.factored = false;
         this.singularBlock = i;
@@ -146,6 +154,70 @@ export class BlockTridiagonal {
     this.factored = true;
   }
 
+  // Block i again, its W and LU with the magnitudes each entry is formed from (as cancellation()
+  // does), perturbing pivots 1e-18 of theirs. Returns the block's pivot ratio.
+  _noisyPivots(i) {
+    const { A, B, sizes, offA, offB, offC, offX } = this, cp = this._cp, lu = this._lu, piv = this._piv;
+    const m = sizes[i], mp = i > 0 ? sizes[i - 1] : 0, oa = offA[i], o = offB[i], oc = i > 0 ? offC[i - 1] : 0;
+    const S = (this._mag ??= new Float64Array(this._tmp.length * this._tmp.length));
+    for (let r = 0; r < m; r++) {
+      for (let c = 0; c < m; c++) {
+        let v = B[o + r * m + c], sum = Math.abs(v);
+        for (let k = 0; k < mp; k++) {
+          const a = A[oa + r * mp + k];
+          if (a === 0) continue;
+          const t = a * cp[oc + k * m + c];
+          v -= t;
+          sum += Math.abs(t);
+        }
+        lu[o + r * m + c] = v;
+        S[r * m + c] = sum;
+      }
+    }
+    let maxEntry = 0;
+    for (let k = 0; k < m * m; k++) maxEntry = Math.max(maxEntry, Math.abs(lu[o + k]));
+    if (maxEntry === 0) return 0;
+    let minPivot = Infinity;
+    for (let k = 0; k < m; k++) {
+      let best = k, bestVal = Math.abs(lu[o + k * m + k]);
+      for (let r = k + 1; r < m; r++) {
+        const v = Math.abs(lu[o + r * m + k]);
+        if (v > bestVal) { best = r; bestVal = v; }
+      }
+      piv[offX[i] + k] = best;
+      if (best !== k) {
+        for (let c = 0; c < m; c++) {
+          let t = lu[o + k * m + c];
+          lu[o + k * m + c] = lu[o + best * m + c];
+          lu[o + best * m + c] = t;
+          t = S[k * m + c];
+          S[k * m + c] = S[best * m + c];
+          S[best * m + c] = t;
+        }
+      }
+      const sum = S[k * m + k];
+      if (bestVal <= 1e-18 * sum || bestVal === 0) {
+        const size = sum > 0 ? 1e-15 * sum : 1e-15 * maxEntry;
+        bestVal = size;
+        lu[o + k * m + k] = lu[o + k * m + k] < 0 ? -size : size;
+        this.perturbedPivots++;
+      }
+      if (bestVal < minPivot) minPivot = bestVal;
+      const inv = 1 / lu[o + k * m + k];
+      for (let r = k + 1; r < m; r++) {
+        const f = (lu[o + r * m + k] *= inv);
+        if (f !== 0) {
+          const af = Math.abs(f);
+          for (let c = k + 1; c < m; c++) {
+            lu[o + r * m + c] -= f * lu[o + k * m + c];
+            S[r * m + c] += af * S[k * m + c];
+          }
+        }
+      }
+    }
+    return minPivot / maxEntry;
+  }
+
   /**
    * Solve with the current factorisation. `rhs` and `out` are Float64Arrays of length `size`
    * (node-major); they may be the same array.

package/src/checks.js

@@ -29,6 +29,11 @@ const sig = (v, p = 3) => (v === 0 || !Number.isFinite(v) ? String(v) : Math.abs
  *   zero; under light it's J = F(G − R), and it says where every carrier went.
  * - **conservation** (a transient): every closed, unreacting stretch keeps what it held plus
  *   what came in.
+ * - **order** (a steady state, with `refine` and `order`, the defaults): the device solved from
+ *   its definition twice, its species listed as given and in reverse, which must give the same
+ *   steady state (each terminal's voltage and current, each species' amount). A solve that
+ *   depends on the listing has converged somewhere that isn't steady without noticing (round 11's
+ *   fuzzer found it in ~1% of random reacting devices, by exactly this test).
  * - **grid** (with `refine`, the default; in a transient, `ok: null` and a reminder, since the
  *   answer depends on the whole run): in a steady state, the device solved again on a grid
  *   twice as fine everywhere, from this solution interpolated onto it. The current, each floating terminal's voltage and each
@@ -37,12 +42,12 @@ const sig = (v, p = 3) => (v === 0 || !Number.isFinite(v) ? String(v) : Math.abs
  *   (about 3/4 of it).
  * @param {import('./index.js').Device} device
  * @param {object} [sol] the solution to check (default: the device's present state)
- * @param {{ refine?: boolean, tol?: number }} [opts]
+ * @param {{ refine?: boolean, tol?: number, order?: boolean }} [opts]
  * Every check passed when `ok`; an item with `ok: null` (a warning, or a check that couldn't be
  * made) asks you to look, and doesn't fail it. `text` is a line per check, marked ok, FAIL or ?.
  * @returns {{ ok: boolean, items: CheckItem[], text: string }}
  */
-export function check(device, sol, { refine = true, tol = 1e-2 } = {}) {
+export function check(device, sol, { refine = true, tol = 1e-2, order = true } = {}) {
   sol ??= device.solution();
   const { model, solver, def } = device;
   const steady = sol.steady ?? solver.atSteady;
@@ -66,8 +71,17 @@ export function check(device, sol, { refine = true, tol = 1e-2 } = {}) {
   // The rest checks a solution, which an unconverged state isn't.
   if (sol.converged) {
     const ledger = steady ? balance(device, sol) : null;
+    // A reaction the steady state needs at equilibrium, left far from it (too slow to see: the
+    // solution warns of it), isn't steady, however quietly its ledgers sum: "equilibrium" was
+    // printed beside that warning.
+    const stuck = steady ? solver.stuckReactions() : [];
+    if (ledger && stuck.length > 0) {
+      ledger.ok = false;
+      ledger.summary = `not a steady state: ${stuck.map((s) => `${s.where} is ${sig(s.affinity * solver.VT * 1e3)} mV of affinity from equilibrium`).join(', ')}, too slow for the solve to see (see the warnings); its ledgers say only that nothing moves fast enough to count`;
+    }
     items.push(ledger ?? conservation(sol, Math.max(...device.model.grid.area)));
     if (steady && refine) items.push(gridCheck(device, sol, tol, ledger.details.gross));
+    if (steady && refine && order && model.species.length > 1) items.push(orderCheck(device, sol, ledger.details.gross));
     // A transient's answer depends on its whole history (and on drives set along the way), so
     // only a run of its own on a finer grid can check it.
     else if (refine) items.push({ name: 'grid', ok: null, summary: 'not checked in a transient: run it again on a grid twice as fine (hmin and hmax halved) and compare' });
@@ -314,6 +328,62 @@ function gridCheck(device, sol, tol, gross) {
   };
 }
 
+// The device solved from its definition with its species listed as given and in reverse: the
+// same steady state either way, or one of them isn't steady. (Both from the definition, not this
+// state, whose closed amounts a transient or set() may have moved from c0.)
+function orderCheck(device, sol, gross) {
+  const { def, model } = device;
+  const solveAt = (d) => {
+    const dev = new Device(d);
+    if (sol.time > 0) dev.solver.time = sol.time; // waveforms at the same time
+    return dev.solve();
+  };
+  let a, b;
+  try {
+    a = solveAt(def);
+    b = solveAt({ ...def, species: [...def.species].reverse() });
+  } catch (e) {
+    return { name: 'order', ok: null, summary: `could not solve the device with its species reversed (${e.message})` };
+  }
+  if (!a.converged || !b.converged) {
+    const which = a.converged ? 'listed in reverse' : b.converged ? 'listed as given' : 'listed either way';
+    return { name: 'order', ok: null, summary: `the device solved from its definition did not converge with its species ${which}: compare with a long advance() by hand` };
+  }
+  const VT = model.RT / FARADAY, diffs = [];
+  // (Currents only where the ledgers see something move: in equilibrium they're round-off of
+  // whatever exchanges fastest, an electrode's couple, and a wrong state shows in the voltages
+  // and amounts instead.)
+  // (and above 1e-16 of what the species could carry, as the grid check's floor: a drift at
+  // 1e-16 A/m², still moving at 1e12 s, isn't worth reporting)
+  const natural = naturalScales(device, sol), floorI = 1e-16 * FARADAY * Math.max(0, ...model.species.map((sp, i) => Math.abs(sp.z) * natural[i]).filter(Number.isFinite));
+  for (const [name, t] of Object.entries(a.terminals)) {
+    const u = b.terminals[name];
+    diffs.push({ what: `${name} voltage`, a: t.V, b: u.V, rel: Math.abs(u.V - t.V) / (1e-6 * Math.max(VT, Math.abs(t.V))), unit: 'V' });
+    if (gross > 0 && Math.max(Math.abs(t.current), Math.abs(u.current), gross) > floorI) diffs.push({ what: `${name} current`, a: t.current, b: u.current, rel: Math.abs(u.current - t.current) / (1e-3 * Math.max(Math.abs(t.current), Math.abs(u.current), gross)), unit: unitsOf(model).current });
+  }
+  const vol = model.grid.vol, amount = (s, name) => s.x.reduce((m, _, g) => m + (Number.isFinite(s.c[name][g]) ? vol[g] * s.c[name][g] : 0), 0);
+  const amounts = model.species.map((sp) => [sp.name, amount(a, sp.name), amount(b, sp.name)]);
+  const most = Math.max(0, ...amounts.map(([, x, y]) => Math.max(Math.abs(x), Math.abs(y))));
+  for (const [name, x, y] of amounts) diffs.push({ what: `${name} amount`, a: x, b: y, rel: Math.abs(y - x) / (1e-6 * Math.max(Math.abs(x), Math.abs(y)) + 1e-12 * most), unit: 'mol/m²' });
+  // Agreeing to near round-off (a µV, a millionth of an amount): ok. Within a thousand times that
+  // (a mV, a thousandth), enough for any plot, but a weakly held part of one solve not quite
+  // steady: look. Beyond: one of them isn't a steady state.
+  const worst = diffs.reduce((w, d) => (d.rel > (w?.rel ?? -1) ? d : w), null);
+  const ok = !(worst.rel > 1) ? true : worst.rel > 1e3 ? false : null;
+  const what = `${worst.what} ${sig(worst.a, 6)} → ${sig(worst.b, 6)} ${worst.unit}`;
+  return {
+    name: 'order',
+    ok,
+    summary:
+      ok === true
+        ? 'the same steady state with the species listed in reverse'
+        : ok === null
+          ? `listed in reverse, the species give nearly the same steady state (${what}): not to round-off, so some weakly held part is not quite steady in one of them`
+          : `listed in reverse, the species give a different steady state: ${what}. One of them is not steady, though its solve converged: compare with a long advance(), and please report the device.`,
+    details: { diffs },
+  };
+}
+
 // Charge density at a node of region r, C/m³: the species plus the region's fixed charge.
 function rho(s, g, model, r) {
   let q = model.regions[r].fixedCharge ?? 0;

package/src/index.js

@@ -63,8 +63,8 @@ export class Device {
   }
 
   /**
-   * Change part of the definition (deep-merged). A contact given V or I drops the other, so
-   * `{ contacts: { right: { I: 0 } } }` switches it to open circuit. Ports are patched by name,
+   * Change part of the definition (deep-merged). A contact given V or I drops the other (and
+   * given I, any series R), so `{ contacts: { right: { I: 0 } } }` switches it to open circuit. Ports are patched by name,
    * `{ ports: { gate: { V: 0.2 } } }` (an array replaces them all). A change to the terminals'
    * drives alone (V, I, R) is applied in place, cheaply. Otherwise the device is rebuilt, keeping the current state as
    * the warm start when the grid and species are unchanged (else restarting from the regions' c0).
@@ -73,7 +73,8 @@ export class Device {
    */
   set(patch) {
     // A terminal given a new kind of drive drops the old one: { I: 0 } replaces a held V.
-    const redrive = (c) => (c && typeof c === 'object' && !Array.isArray(c) ? ('I' in c && !('V' in c) ? { ...c, V: undefined } : 'V' in c && !('I' in c) ? { ...c, I: undefined } : c) : c);
+    // (A current drives a terminal alone: given I, a contact drops V and any series R too.)
+    const redrive = (c) => (c && typeof c === 'object' && !Array.isArray(c) ? ('I' in c && !('V' in c) ? { ...c, V: undefined, ...('R' in c ? {} : { R: undefined }) } : 'V' in c && !('I' in c) ? { ...c, I: undefined } : c) : c);
     for (const side of ['left', 'right']) {
       const c = patch?.contacts?.[side];
       if (c && typeof c === 'object') patch = { ...patch, contacts: { ...patch.contacts, [side]: redrive(c) } };

package/src/solution.js

@@ -152,6 +152,16 @@ export function makeSolution(solver, result = {}) {
     }
     return out;
   });
+  // A floating terminal passes what its circuit says, exactly (see passedCurrent).
+  if (sol.converged) {
+    for (const k of solver.floating) {
+      const I = solver.passedCurrent(k);
+      if (k === 0) sol.contacts.left.current = I;
+      else if (k === 1) sol.contacts.right.current = -I;
+      else sol.ports[k - 2].current = I;
+    }
+  }
+  sol.current = sol.contacts.right.current;
   sol.terminalVoltage = sol.contacts.right.V - sol.contacts.left.V;
   // Every terminal (the contacts, then the ports by name): its voltage and its current into the
   // device, conduction plus displacement. They sum to zero in steady state.
@@ -361,6 +371,15 @@ export function makeSolution(solver, result = {}) {
       }
     });
   });
+  // A reaction a steady state needs at equilibrium, left out of it (see stuckReactions).
+  if (sol.steady) {
+    for (const { where, affinity } of solver.stuckReactions()) {
+      sol.warnings.push(
+        `${where}: out of equilibrium by ${(affinity * solver.VT * 1e3).toPrecision(3)} mV of affinity wherever it acts, yet nothing else makes or uses what it changes, so a steady state needs it at equilibrium. ` +
+          'Its rate is too small for the solve to resolve, and it was left where the solve began: this is not a steady state. Raise its rate constant (the steady state does not depend on it), or advance() in time to see how slowly it gets there.',
+      );
+    }
+  }
   // Any other species denser than any material can be (1e6 mol/m³: water is 5.5e4, a metal's
   // atoms ~1.5e5): a level set where the device can't follow it, such as a contact's for one ion
   // far from its neighbours' (Na⁺ held at 1.2e37 mol/m³, whose currents then read 1e28 A/m²).

package/src/solver.js

@@ -491,7 +491,7 @@ export class Solver {
     this.steady = false; // inside a steady solve: sources at the present time, not a step's end
     // The floating ones are extra unknowns, solved with the grid's by bordering (_solveBordered).
     this.floating = this.terms.flatMap((t, k) => (t.drive.kind === 'I' || t.drive.R > 0 ? [k] : []));
-    this.drivenKey = this.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}`).join();
+    this.drivenKey = this._drivenKey();
     this.lawRefs = new Map(); // what a steady solve keeps behind a terminal at no current (_captureLaws)
     this.chargeRefs = new Map(); // …and the charge a terminal at no current that only charges keeps
     // Per terminal: B = ∂res/∂V (compact column), C = ∂I/∂x (compact row), ∂I/∂V, and for a
@@ -882,6 +882,73 @@ export class Solver {
     // first, so that the first takes that row, and the rest have its multiple taken off.
     const through = (w) => this.carriers.some((k, j) => w[X + j] !== 0);
     const held = new Map(); // (terminal → the combination in place of its circuit row)
+    // Reactions' equilibria first. A face reaction that alone changes some combination (without
+    // it, w would be conserved: Ag⁺ closed in a cell where Ag⁺ + e⁻ = Ag(s) is its one source, or
+    // Ag⁺ + AgNO₃ where it also complexes) has that combination's summed balance rows equal to its
+    // rate, w·ν times it, which a steady state sets to zero. The rate is a poor row: k₀ times a
+    // function of the levels, beside diffusion's terms in the same balances. An Ag⁺/Ag couple
+    // 1e-20 as fast as Fe³⁺/Fe²⁺ on the same platinum was lost to their round-off, the
+    // open-circuit potential settling where silver wasn't (−0.4661 V, the joint equilibrium
+    // −0.5004 V), and 1e-15 to 1e-18 failed. Its affinity says the same at any k₀ (each kinetic
+    // form vanishes only there), so it stands in for one of those rows (see _applyAffinities),
+    // chosen by the same elimination, and a stretch's: never a circuit row.
+    // The slowest first, whose rate rows are the poorest, and each row picked by the reaction's
+    // own terms, never by where its species are listed: the same rows in any listing. (Picked by
+    // listing, an electrode's two couples took different rows with the species reversed, and
+    // Newton converged in one listing and crawled in the other.)
+    this.affinities = [];
+    const faceRx = model.interfaces.flatMap((itf, f) => itf.reactions.map((rx) => ({ f, rx, key: rx.part.map((p) => `${model.species[p.i].name}:${p.side}:${p.nu}`).sort().join() })));
+    faceRx.sort((a, b) => a.rx.k0 - b.rx.k0 || (a.key < b.key ? -1 : a.key > b.key ? 1 : a.f - b.f));
+    for (const { f, rx } of faceRx) {
+      const nu = new Float64Array(S);
+      let inFlat = false;
+      for (const p of rx.part) {
+        const k = this.stretchOf[(f + p.side) * this.n + p.i];
+        if (k < 0 || this.flatStretches.includes(this.stretches[k])) inFlat = true;
+        else nu[k] += p.nu;
+      }
+      if (inFlat) continue; // (held flat at a contact's levels, in equilibrium already)
+      // (Not one fed by a terminal driven by a current: its sum is the rate plus what that
+      // passes. Silver's, e⁻ + Fe²⁺ with the electrons fed, or Ag⁺ + AgNO₃, which nothing is.
+      // A current held at zero passes nothing: an electrode at open circuit feeding a closed
+      // pool of Ag⁺ beside a slow Fe³⁺/Fe²⁺ couple settled 78 mV off, its iron not stationary.)
+      const passes = (k) => !this._noCurrent(this.terms[k]);
+      const fed = (w) => w.some((x, k) => x !== 0 && ((k >= X && passes(this.carriers[k - X])) || (k < S && driven(this.stretches[k]).some(passes))));
+      // Any of the combinations it alone changes will do, with any conserved amount added (whose
+      // summed balance is zero too): one of them needs a row of its own left to take. (Silver's,
+      // e⁻ − Fe³⁺ beside a closed iron couple that had Fe³⁺'s, is e⁻ + Fe²⁺ with the iron added.)
+      const news = this._conservedMoieties(true, [], rx).filter((w) => Math.abs(nu.reduce((t, x, k) => t + x * w[k], 0)) > 1e-9 && !fed(w));
+      const kept = laws.filter((l) => !fed(l));
+      const tries = [...news, ...news.flatMap((w) => kept.flatMap((l) => [1, -1].map((sg) => w.map((x, m) => x + sg * l[m]))))];
+      for (const w of tries) {
+        const v = new Float64Array(S + T);
+        for (let k = 0; k < S; k++) {
+          if (w[k] === 0) continue;
+          const st = this.stretches[k];
+          if (this._moves(st) && !spectators.has(rowOf(k))) v[k] = w[k];
+          if (this.z[st.species] !== 0) for (const t of driven(st)) v[S + t] = w[k] / this.z[st.species];
+        }
+        for (const [col, row] of chosen) {
+          const fc = v[col];
+          if (fc !== 0) for (let j = 0; j < S + T; j++) v[j] -= fc * row[j];
+        }
+        const scale = v.reduce((m, x) => Math.max(m, Math.abs(x)), 0);
+        if (!(scale > 1e-9)) continue;
+        // (Never a metal's carriers, nor a stretch a terminal feeds, even at no current: their rows
+        // carry the terminal's current, and Pt's electrons standing for an iron couple's balance
+        // put the electrode at 602 V.)
+        const ok = (j) => j !== undefined && j >= 0 && j < S && Math.abs(v[j]) > 1e-9 * scale && !conductor(this.stretches[j]) && this.terms.every((_, t) => !this._feeds(t, this.stretches[j]));
+        // (One of its own species first, then weight 1, the largest, and by name.)
+        const own = (k) => rx.part.some((p) => p.i === this.stretches[k].species && this.stretchOf[(f + p.side) * this.n + p.i] === k);
+        const key = (k) => [own(k) ? 0 : 1, Math.abs(v[k]) === 1 ? 0 : 1, -Math.abs(v[k]), model.species[this.stretches[k].species].name, this.stretches[k].regions[0]];
+        const less = (a, b) => { const ka = key(a), kb = key(b); for (let j = 0; j < ka.length; j++) if (ka[j] !== kb[j]) return ka[j] < kb[j]; return false; };
+        const col = [...Array(S).keys()].filter(ok).reduce((b, k) => (b < 0 || less(k, b) ? k : b), -1);
+        if (col < 0) continue;
+        chosen.push([col, v.map((x) => x / v[col])]);
+        this.affinities.push({ rx, f, row: rowOf(col), idx: new Int32Array(rx.part.length), w: new Float64Array(rx.part.length), len: 0, res: 0 });
+        break;
+      }
+    }
     for (let w of [...laws.filter(through), ...laws.filter((w) => !through(w))]) {
       for (const [j, k] of this.carriers.entries()) {
         const c = held.get(k);
@@ -947,7 +1014,7 @@ export class Solver {
     this.pinnedIslands = [];
     this.islandsOn = false; // (newton() turns them on, see there)
     this.pins = [];
-    const used = new Set(this.constraints.map((cs) => cs.row).filter((o) => o >= 0));
+    const used = new Set([...this.constraints.map((cs) => cs.row).filter((o) => o >= 0), ...this.affinities.map((af) => af.row)]);
     for (const st of this.stretches) {
       const i = st.species, [s0, s1] = st.regions;
       if (!st.mobile || conductor(st)) continue;
@@ -1160,7 +1227,7 @@ export class Solver {
   // charges, so a combination weighted by z there is conserved while it passes none: a battery's
   // cathode, its electrons behind an open circuit, keeps its charge. Exact integer data, so plain
   // elimination will do.
-  _conservedMoieties(drives = false, alsoCurrent = []) {
+  _conservedMoieties(drives = false, alsoCurrent = [], skip = null) {
     const { model, n, z } = this, S = this.stretches.length;
     // With `drives`, an electrode port driven by a current whose reactions take its carrier from
     // the electrode has a column of its own, last: what the electrode holds, its charge Q/(zF),
@@ -1169,12 +1236,14 @@ export class Solver {
     const byCurrent = (t, k) => t.drive.kind === 'I' || alsoCurrent.includes(k); // (with `alsoCurrent`, terminals counted as such)
     this.carriers = drives ? this.terms.flatMap((t, k) => (byCurrent(t, k) && k >= 2 && model.ports[k - 2].reactions.length > 0 ? [k] : [])) : [];
     const X = S + this.surfCols.length, C = X + this.carriers.length;
-    const rows = [];
+    // (With `skip`, a reaction left out: the combinations that it alone changes come out too, and
+    // its own rows, over the columns, are handed back as `basis.skipped`.)
+    const rows = [], skipped = [];
     model.interfaces.forEach((itf, f) => {
       for (const rx of itf.reactions) {
         const row = new Float64Array(C);
         for (const p of rx.part) row[this.stretchOf[(f + p.side) * n + p.i]] += p.nu;
-        rows.push(row);
+        (rx === skip ? skipped : rows).push(row);
       }
     });
     // An electrode surface's species are columns too, after the stretches (S + j for surface
@@ -1183,12 +1252,13 @@ export class Solver {
     model.ports.forEach((port, k) => {
       for (const rx of port.reactions) {
         const row = new Float64Array(C); // (the electrode's carrier is outside the device)
+        if (rx === skip) skipped.push(row);
         for (const p of rx.part) {
           if (p.side === 0) row[this.stretchOf[port.region * n + p.i]] += p.nu;
           else if (p.side === 2) row[S + this.surfColOf[k] + p.s] += p.nu;
           else if (this.carriers.includes(k + 2)) row[X + this.carriers.indexOf(k + 2)] += p.nu;
         }
-        rows.push(row);
+        if (rx !== skip) rows.push(row);
       }
     });
     model.regions.forEach((reg, q) => {
@@ -1197,7 +1267,7 @@ export class Solver {
         const row = new Float64Array(C);
         for (const p of rx.reactants) row[this.stretchOf[q * n + p.i]] -= p.nu;
         for (const p of rx.products) row[this.stretchOf[q * n + p.i]] += p.nu;
-        rows.push(row);
+        (rx === skip ? skipped : rows).push(row);
       }
     });
     const unit = (k) => {
@@ -1254,6 +1324,7 @@ export class Solver {
       w.own = free; // (its weight is 1 there, and no other vector's is: the row it replaces)
       basis.push(w);
     }
+    basis.skipped = skipped;
     return basis;
   }
 
@@ -1508,12 +1579,67 @@ export class Solver {
     if (this.floating.length !== before.length) this.deltaV = null;
     // A terminal newly driven by a current (or no longer) can close a combination behind it.
     // (and one put behind a resistance, or taken from it, its time steps' reading: see _laws)
-    this.drivenKey = this.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}`).join();
+    this.drivenKey = this._drivenKey();
     if (this.drivenKey !== driven) this._laws();
     this._refreshSources();
     this.history = [];
   }
 
+  // After a steady solve: each reaction that alone changes some combination nothing else feeds
+  // (see _laws), whose total rate a steady state therefore sets to zero, but whose affinity has one
+  // sign wherever it acts, so that its total can't be zero. Too slow to show, its rate lost to
+  // round-off, it was left where the solve began: a slow complexation 43 mV off, an electrode
+  // port's slow couple at its starting composition, each converged without a word. (A face
+  // reaction stands on its affinity, so it's only caught here if that couldn't be arranged.)
+  stuckReactions() {
+    const { n, M, u, uLo, model } = this, grid = model.grid, S = this.stretches.length, X = S + this.surfCols.length, out = [];
+    const passes = (k) => !this._noCurrent(this.terms[k]);
+    const fed = (w) => w.some((x, k) => x !== 0 && ((k >= X && passes(this.carriers[k - X])) || (k < S && this.terms.some((t, j) => t.drive.kind === 'I' && passes(j) && this._feeds(j, this.stretches[k])))));
+    const needed = (rx) => {
+      const basis = this._conservedMoieties(true, [], rx);
+      return basis.some((w) => !fed(w) && basis.skipped.some((row) => Math.abs(row.reduce((t, x, k) => t + x * w[k], 0)) > 1e-9));
+    };
+    const eta = (g, slot) => u[this.blockOfNode[g] * M + slot] + uLo[this.blockOfNode[g] * M + slot];
+    const report = (where, as) => {
+      if (as.length === 0 || !(as.every((a) => a > 1e-6) || as.every((a) => a < -1e-6))) return;
+      out.push({ where, affinity: as.reduce((m, a) => (Math.abs(a) < Math.abs(m) ? a : m)) });
+    };
+    model.interfaces.forEach((itf, f) => {
+      const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1];
+      itf.reactions.forEach((rx, q) => {
+        if (this.affinities.some((af) => af.rx === rx) || !needed(rx)) return;
+        report(`interfaces[${f}].reactions[${q}]`, [rx.part.reduce((a, p) => a - p.nu * eta(p.side ? gR : gL, 1 + p.i), rx.fixedA)]);
+      });
+    });
+    model.reactions.forEach((mrx, x) => {
+      const rx = this.rxs[x];
+      if (rx.generation || !needed(mrx)) return;
+      const as = [];
+      for (let g = 0; g < this.nNodes; g++) if (rx.kfNode[g] > 0 || rx.srh?.[this.nodeMaterial[g]]) as.push(rx.sp.reduce((a, i, p) => a + rx.nu[p] * eta(g, 1 + i), rx.fixedA));
+      report(`bulkReactions[${x}]`, as);
+    });
+    model.ports.forEach((port, k) => {
+      port.reactions.forEach((rx, q) => {
+        if (!needed(rx)) return;
+        let aV = rx.fixedA;
+        for (const p of rx.part) if (p.side === 1) aV -= p.nu * this.portEta(port, p.i);
+        report(`ports[${k}].reactions[${q}]`, port.nodes.map((g) => rx.part.reduce((a, p) => (p.side === 1 ? a : a - p.nu * eta(g, p.side === 2 ? 1 + n + p.s : 1 + p.i)), aV)));
+      });
+    });
+    return out;
+  }
+
+  // How each terminal is driven, as far as the laws care (see _laws): by a voltage or a current,
+  // behind a resistance or not, and a current that's held at zero throughout (which feeds a
+  // combination nothing, so a reaction's affinity may stand in for its summed balance).
+  _drivenKey() {
+    return this.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}${this._noCurrent(t) ? '0' : ''}`).join();
+  }
+
+  _noCurrent(t) {
+    return t.drive.kind === 'I' && !(t.drive.R > 0) && t.drive.src.value === 0;
+  }
+
   // Held terminals take their sources' values at sourceTime (a floating one keeps its voltage,
   // an unknown; one behind a resistance reads its source voltage in _circuit).
   _refreshSources() {
@@ -2031,10 +2157,11 @@ export class Solver {
     // balances, the last two kept aside for _solveBordered.
     const steady = this.steady && dt === Infinity;
     if (steady) this._flatRows();
+    if (steady && this.affinities.length > 0) this._applyAffinities();
     if (steady && this.constraints.length > 0) this._applyConstraints();
     if (steady && this.localConstraints.length > 0) this._applyLocalConstraints();
     this.pinnedIslands = steady && this.islandsOn ? this._applyIslands() : [];
-    this.pins = steady ? [...this.constraints.filter((cs) => cs.circuit < 0), ...this.pinnedIslands] : [];
+    this.pins = steady ? [...this.constraints.filter((cs) => cs.circuit < 0), ...this.affinities, ...this.pinnedIslands] : [];
     this.transformed = this.combining && dt !== Infinity;
     if (this.transformed) this._chargeRows(dt);
   }
@@ -3274,6 +3401,31 @@ export class Solver {
     }
   }
 
+  // Steady solves: each reaction that alone changes a combination (see _laws) held at its
+  // equilibrium, a = fixedA − Σ ν η = 0, in place of one of that combination's balance rows (a pin,
+  // like an amount's).
+  _applyAffinities() {
+    const { M, u, uLo, res } = this, grid = this.model.grid;
+    for (const af of this.affinities) {
+      const b0 = Math.floor(af.row / M), r0 = af.row % M;
+      this._replaceRow(b0, r0);
+      this._j(b0, r0, b0, r0, 1);
+      res[this.rix[af.row]] = 0;
+      const gL = grid.regionEnd[af.f], gR = grid.regionStart[af.f + 1];
+      let hi = af.rx.fixedA, lo = 0, len = 0;
+      for (const p of af.rx.part) {
+        const o = this.blockOfNode[p.side ? gR : gL] * M + 1 + p.i;
+        hi -= p.nu * u[o];
+        lo -= p.nu * uLo[o];
+        if (this.loc[o] < 0) continue;
+        af.idx[len] = this.rix[o];
+        af.w[len++] = -p.nu;
+      }
+      af.len = len;
+      af.res = hi + lo;
+    }
+  }
+
   // Zero one row of the Jacobian (all three blocks), ready to be replaced.
   _replaceRow(b, rs) {
     const l = this.loc[b * this.M + rs];
@@ -3411,8 +3563,13 @@ export class Solver {
       // stops refining.
       const x0 = Float64Array.from(x);
       const ok = gmresReal(op, pb, x, { m: 8, restarts: 1, tol: 1e-8 });
-      let c = 0;
-      for (let j = 0; j < N + K; j++) c = Math.max(c, Math.abs(x[j] - x0[j]));
+      // (Measured on the potentials, as Newton's own step is: a rate the plain solve left
+      // unsolved, at a perturbed pivot, can need a correction of 41.7 mol/(m²·s).)
+      const dx = new Float64Array(N + 1), dV = new Float64Array(K);
+      for (let j = 0; j < N; j++) dx[j] = x[j] - x0[j];
+      for (let a = 0; a < K; a++) dV[a] = x[N + a] - x0[N + a];
+      if (this.transformed) this._untransform(dx);
+      const c = this._maxPotentialStep(dx, dV);
       if (!ok || !(c < 1)) return false;
       for (let j = 0; j < N; j++) delta[j] = x[j];
       for (let a = 0; a < K; a++) deltaV[a] = x[N + a];
@@ -3464,7 +3621,19 @@ export class Solver {
     // A/m² of noise), their rows can throw Newton off instead: if it doesn't converge again
     // within a dozen iterations, the plain solution stands.
     this.islandsOn = islands;
-    let rounds = 0, kept = null;
+    let rounds = 0, kept = null, perturbed = false;
+    // Converged by a small update, but solved at a perturbed pivot, or in a steady solve (where a
+    // factorisation that lost a row's digits left a reaction's rate 3.6e7 off it, the update
+    // small, an I = 0 electrode at a voltage 0.4 V from its steady one): the residual itself,
+    // assembled at the state, must be small too (each row scaled by its largest Jacobian entry).
+    const unsolved = () => {
+      if (!perturbed && dt !== Infinity) return false;
+      this.assemble(dt);
+      this._equilibrate();
+      let r = 0;
+      for (let k = 0; k < this.SINK; k++) r = Math.max(r, Math.abs(this.res[k]));
+      return !(r < 1e-6);
+    };
     const islandsOff = (it, result) => {
       if (dt !== Infinity || !this.steady || this.islands.length === 0 || rounds >= 2 || !(this._kirchhoff() > 1e-9)) return false;
       this.islandsOn = true;
@@ -3509,6 +3678,13 @@ export class Solver {
       } catch (err) {
         return fail({ converged: false, iterations: it, history, error: err.message });
       }
+      // A pivot perturbed (one that cancelled to exactly nothing) can leave a row unsolved, its
+      // update small while its residual isn't: the same couple written twice on an electrode at
+      // open circuit converged with one spelling's rate row 41.7 mol/(m²·s) off, the couple
+      // 1.5 RT from equilibrium. Refine the solves (exact J·v) wherever one was, and before
+      // taking a small update for convergence there, look at the residual itself (see unsolved).
+      perturbed = this.sys.perturbedPivots > 0;
+      if (perturbed && !noRefine) refine = true;
       try {
         const pins = this.pins;
         deltaV.fill(0);
@@ -3547,6 +3723,7 @@ export class Solver {
       const last = history[history.length - 2], theta = step / last;
       const contracted = dt !== Infinity && it >= 2 && step < 1e-6 && theta < 0.1 && (theta / (1 - theta)) * step < tol;
       if (alpha === 1 && (step < tol || contracted)) {
+        if (unsolved()) return fail({ converged: false, iterations: it, history, error: 'a row left unsolved at a pivot that cancelled exactly' });
         const done = { converged: true, iterations: it, history, residual: rmax };
         if (islandsOff(it, done)) continue;
         this.computeConcentrations();
@@ -3567,6 +3744,7 @@ export class Solver {
       if (refine) refined++;
       else if (!noRefine && alpha === 1 && it >= 3 && step > 0.25 * p1 && (step < 1e-4 || (step > p1 && p1 > p2))) refine = true;
       if (alpha === 1 && it >= 4 && (!refine || refined >= 1 || noRefine) && step < floor && p1 < floor && step > 0.25 * p1 && p1 > 0.25 * p2) {
+        if (unsolved()) return fail({ converged: false, iterations: it, history, error: 'a row left unsolved at a pivot that cancelled exactly' });
         const done = { converged: true, iterations: it, history, residual: rmax, roundoff: true };
         if (islandsOff(it, done)) continue;
         this.computeConcentrations();
@@ -3676,11 +3854,7 @@ export class Solver {
       this.portQEnd = Float64Array.from(this.portQ);
     }
     const DN = { ...this.contactDEnd }, QN = Float64Array.from(this.portQEnd);
-    if (opts.guess) {
-      // Start Newton from a predicted state (e.g. extrapolated from the history).
-      this.u.set(opts.guess);
-      this.uLo.fill(0);
-    }
+    if (opts.guess) this._guess(opts.guess); // start Newton from a predicted state
     let dtEff = dt;
     if (bdf) {
       const a0 = (1 + 2 * w) / (1 + w), b1 = (1 + w) / a0, b2 = (w * w) / (1 + w) / a0;
@@ -3717,10 +3891,7 @@ export class Solver {
         this.u.set(this.uPrev);
         this.uLo.set(this.uPrevLo);
         this.termV.set(this.termVPrev);
-        if (opts.guess) {
-          this.u.set(opts.guess);
-          this.uLo.fill(0);
-        }
+        if (opts.guess) this._guess(opts.guess);
         const again = this.newton(dtEff, { ...opts, islands: true });
         result = { ...again, iterations: result.iterations + again.iterations };
       }
@@ -3730,10 +3901,7 @@ export class Solver {
         this.u.set(this.uPrev);
         this.uLo.set(this.uPrevLo);
         this.termV.set(this.termVPrev);
-        if (opts.guess) {
-          this.u.set(opts.guess);
-          this.uLo.fill(0);
-        }
+        if (opts.guess) this._guess(opts.guess);
         for (const cs of this.lawForm.keys()) this.lawForm.set(cs, true);
         const again = this.newton(dtEff, opts);
         result = { ...again, iterations: result.iterations + again.iterations };
@@ -3766,6 +3934,19 @@ export class Solver {
     return result;
   }
 
+  // Newton's unknowns set to a guess (e.g. extrapolated from the history). Only its unknowns: the
+  // other slots never change (see _activeSlots), and among them is a gauge, an insertion host's
+  // φ̂, that nothing pulls back. Extrapolated through steps that grow, it wandered off
+  // geometrically, 147 to 8000 thermal units in a battery's first 100 s and 1e11 by 1e5 s, where
+  // its species' levels (η − zφ̂, summed back by the host's statistics) lost their digits to it.
+  _guess(guess) {
+    const { u, uLo } = this;
+    for (const k of this.fullOf) {
+      u[k] = guess[k];
+      uLo[k] = 0;
+    }
+  }
+
   /**
    * Adaptive time stepping to tEnd: variable-step BDF2 (or backward Euler), with the local error
    * estimated against an explicit predictor through the previous states, and controlled to
@@ -3788,6 +3969,7 @@ export class Solver {
     // Already there (an animation frame with no time to add): nothing to do, and the step size
     // carried to the next call stays as it was.
     if (!(tEnd > this.time)) return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace };
+    const t0 = this.time;
     let dt = this.dtNext ?? opts.dt0 ?? (tEnd - this.time) * 1e-4;
     if (!(dt > 0)) dt = (tEnd - this.time) * 1e-4;
     // The shortest step worth trying: round-off relative to the time, or the device's fastest
@@ -3800,8 +3982,10 @@ export class Solver {
       if (steps + rejected >= maxSteps || clock() - start > budgetMs) break;
       // Within round-off of the end (a target a hair past a breakpoint just landed on, say):
       // snap to it rather than attempt a step of ~1e-13 s, which can't be resolved and, in a
-      // strictly neutral device, fails outright.
-      if (tEnd - this.time <= 1e-10 * Math.abs(tEnd)) {
+      // strictly neutral device, fails outright. Round-off of the time and negligible beside the
+      // interval asked for: by the time alone, a GITT pulse of 0.01 s at t = 1e9 s was skipped
+      // whole (the time moved, nothing else did), and from 1e10 s 17% of a pulse train's charge.
+      if (tEnd - this.time <= 1e-10 * Math.abs(tEnd) && tEnd - this.time <= 1e-9 * (tEnd - t0)) {
         this.time = tEnd;
         break;
       }
@@ -3895,7 +4079,10 @@ export class Solver {
     // Stopped short, other than on the caller's wall-time budget: say where, and why.
     let stopped;
     const at = `advance stopped at t = ${this.time.toPrecision(6)} s of ${tEnd.toPrecision(6)}`;
-    if (failed) stopped = `${at}: a step didn't converge even when shortened to ${dt.toExponential(1)} s. A drive's jump too big for one step (ramp it), a driven current the device can't keep passing (a diode's reverse recovery past its storage time: stop there), or a device the steady solves also find hard.`;
+    // (What usually does it, most likely first. Round 11's agents read the old list, which led
+    // with a drive's jump, as blaming a modest current pulse: a host emptied at its surface, and
+    // an electrode at open circuit with no double layer, held only by a slow reaction.)
+    if (failed) stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. Look for: a host or surface driven to its limit (emptied or filled at its surface by a current it can no longer pass); an electrode at open circuit held only by a slow reaction, with no double-layer capacitance to keep its level (give its face one: phi capacitive); a drive's jump too big for one step (ramp it); a driven current the device cannot keep passing (a diode's reverse recovery past its storage time: stop there); or a device the steady solves also find hard.`;
     else if (this.time < tEnd && steps + rejected >= maxSteps) stopped = `${at}: maxSteps (${maxSteps}) used up (${rejected} of them rejected). Call again to go on, or loosen tol.`;
     return { converged: !failed, done: this.time >= tEnd, steps, rejected, iterations, trace, ...(stopped ? { stopped } : {}) };
   }
@@ -4113,8 +4300,19 @@ export class Solver {
     this.computeConcentrations();
   }
 
+  // What a floating terminal k passes into the device, which its circuit row holds exactly once
+  // converged: the current it's driven by, or (V_source − V)/R behind a resistance (the source
+  // as the last step saw it, before any jump at its end). Read as a flux through a metal instead,
+  // it carried that flux's round-off, G Δη with G huge: a gate behind R read 1.5e-4 off wherever
+  // Newton stopped an update early, and below ~1e-16 A/m², nothing but noise.
+  passedCurrent(k) {
+    const d = this.terms[k].drive, src = sourceAt(d.src, this.time, !this.atSteady);
+    return d.kind === 'I' ? src : (src - this.termV[k]) / d.R;
+  }
+
   // Terminal current toward +x at the right contact, from the last assembly at this state.
   _terminalCurrent() {
+    if (this.floating.includes(1)) return -this.passedCurrent(1);
     let I = 0;
     for (let i = 0; i < this.n; i++) I += FARADAY * this.z[i] * this.contactFlux.right[i];
     const dt = this.lastDt;

package/types/blockTridiagonal.d.ts

@@ -46,6 +46,7 @@ export class BlockTridiagonal {
      * Throws if a diagonal block is exactly singular (unless `staticPivots`).
      */
     factor(): void;
+    _noisyPivots(i: any): number;
     /**
      * Solve with the current factorisation. `rhs` and `out` are Float64Arrays of length `size`
      * (node-major); they may be the same array.

package/types/checks.d.ts

@@ -18,6 +18,11 @@
  *   zero; under light it's J = F(G − R), and it says where every carrier went.
  * - **conservation** (a transient): every closed, unreacting stretch keeps what it held plus
  *   what came in.
+ * - **order** (a steady state, with `refine` and `order`, the defaults): the device solved from
+ *   its definition twice, its species listed as given and in reverse, which must give the same
+ *   steady state (each terminal's voltage and current, each species' amount). A solve that
+ *   depends on the listing has converged somewhere that isn't steady without noticing (round 11's
+ *   fuzzer found it in ~1% of random reacting devices, by exactly this test).
  * - **grid** (with `refine`, the default; in a transient, `ok: null` and a reminder, since the
  *   answer depends on the whole run): in a steady state, the device solved again on a grid
  *   twice as fine everywhere, from this solution interpolated onto it. The current, each floating terminal's voltage and each
@@ -26,14 +31,15 @@
  *   (about 3/4 of it).
  * @param {import('./index.js').Device} device
  * @param {object} [sol] the solution to check (default: the device's present state)
- * @param {{ refine?: boolean, tol?: number }} [opts]
+ * @param {{ refine?: boolean, tol?: number, order?: boolean }} [opts]
  * Every check passed when `ok`; an item with `ok: null` (a warning, or a check that couldn't be
  * made) asks you to look, and doesn't fail it. `text` is a line per check, marked ok, FAIL or ?.
  * @returns {{ ok: boolean, items: CheckItem[], text: string }}
  */
-export function check(device: import("./index.js").Device, sol?: object, { refine, tol }?: {
+export function check(device: import("./index.js").Device, sol?: object, { refine, tol, order }?: {
     refine?: boolean;
     tol?: number;
+    order?: boolean;
 }): {
     ok: boolean;
     items: CheckItem[];

package/types/index.d.ts

@@ -13,8 +13,8 @@ export class Device {
     get solver(): any;
     get grid(): any;
     /**
-     * Change part of the definition (deep-merged). A contact given V or I drops the other, so
-     * `{ contacts: { right: { I: 0 } } }` switches it to open circuit. Ports are patched by name,
+     * Change part of the definition (deep-merged). A contact given V or I drops the other (and
+     * given I, any series R), so `{ contacts: { right: { I: 0 } } }` switches it to open circuit. Ports are patched by name,
      * `{ ports: { gate: { V: 0.2 } } }` (an array replaces them all). A change to the terminals'
      * drives alone (V, I, R) is applied in place, cheaply. Otherwise the device is rebuilt, keeping the current state as
      * the warm start when the grid and species are unchanged (else restarting from the regions' c0).

package/types/solver.d.ts

@@ -143,6 +143,7 @@ export class Solver {
     _feeds(k: any, st: any): any;
     _laws(): void;
     constraints: any[];
+    affinities: any[];
     localConstraints: any[];
     islands: any[];
     pinnedIslands: any[];
@@ -157,7 +158,7 @@ export class Solver {
     _rowInto(o: any, add: any): void;
     linRow: Float64Array<any>;
     _applyLocalConstraints(): void;
-    _conservedMoieties(drives?: boolean, alsoCurrent?: any[]): Float64Array<any>[];
+    _conservedMoieties(drives?: boolean, alsoCurrent?: any[], skip?: any): Float64Array<any>[];
     _directSteady(): boolean;
     _applyConstraints(): void;
     _lawAmount(cs: any): {
@@ -178,6 +179,9 @@ export class Solver {
     amount(stretch: any): number;
     redrive(): void;
     deltaV: Float64Array<any>;
+    stuckReactions(): any[];
+    _drivenKey(): any;
+    _noCurrent(t: any): boolean;
     _refreshSources(): void;
     /** η_i (μ̄/RT) of a port's outside level for species i (its electrode's carrier: at V itself). */
     portEta(port: any, i: any): number;
@@ -256,6 +260,7 @@ export class Solver {
     };
     _snapFlat(): void;
     _flatRows(): void;
+    _applyAffinities(): void;
     _replaceRow(b: any, rs: any): void;
     _equilibrate(): void;
     _assembleDifference(dt: any): {
@@ -312,6 +317,7 @@ export class Solver {
     sourceBefore: boolean;
     solvedV: any;
     stepped: boolean;
+    _guess(guess: any): void;
     /**
      * Adaptive time stepping to tEnd: variable-step BDF2 (or backward Euler), with the local error
      * estimated against an explicit predictor through the previous states, and controlled to
@@ -374,6 +380,7 @@ export class Solver {
         sourceTime: number;
     };
     _restore(s: any): void;
+    passedCurrent(k: any): any;
     _terminalCurrent(): number;
     /**
      * Small-signal impedance about the current (steady) state, seen at one terminal. Linearising