driftlet 1.3.0 → 1.3.2

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@1.3.0/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@1.3.2/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).
 

package/docs/device.md

@@ -112,9 +112,11 @@ regions: [
   material. In a strictly neutral region, $`\sum z \cdot c_0`$ must be zero.
   Where two strictly neutral regions meet at a face that holds ions in equilibrium and their
   `c0` leaves it out of equilibrium (a different fixed charge or immobile ion on each side), the
-  two nodes at the face start in it, as the face reaches it at $`t = 0^+`$: the ions it passes
-  shared between them so their $`\bar\mu`$ is equal across it and each side neutral, each
-  one's amount over the two nodes kept, everything else as `c0` has it.
+  two nodes at the face start a transient in it, as the face reaches it at $`t = 0^+`$: the ions
+  it passes shared between them so their $`\bar\mu`$ is equal across it and each side neutral,
+  each one's amount over the two nodes kept, everything else as `c0` has it. (The first time
+  step from a cold start does this; a steady solve starts from `c0` as given, which it reaches
+  better from.)
   An entry can instead be a profile, `{ x: [...], values: [...] }`, against the device's x (m, not
   the region's own), piecewise linear between its points and constant beyond its ends, so a
   transient can start from a state it didn't simulate reaching: a packet already injected, a
@@ -541,6 +543,12 @@ levels are that material's, and the end node takes them through a Donnan step.
   means. For example, a Schottky barrier $`\phi_B`$ on n-type material with
   $`\mu^\circ_{\mathrm{e}^-} = 0`$ is `zeroCharge: φ_B`.
 
+An ideally blocking electrode (inert: no reactions, nothing crossing) is a contact with no
+terminal species and no links, `{ V, phi: 'pinned', zeroCharge }`: the solution's diffuse layer
+is its whole double layer (the validation suite's Macdonald impedance is this cell), and a Stern layer in
+series is `phi: { type: 'capacitive', C }` in place of `'pinned'`. (A metal layer behind a
+capacitive face of large C does the same at more cost, and its C is warned of as a unit slip.)
+
 A Schottky contact is that pinned barrier with its carriers passing at their emission velocities:
 `{ V, terminal: 'e-', species: { 'e-': { type: 'velocity', v }, 'h+': { type: 'velocity', v: vp, offset: 0 } }, phi: 'pinned', zeroCharge: φ_B }`,
 with Bethe's thermionic-emission velocity $`v = A^* T^2/(F N_c)`$ ($`N_c`$ in mol/m³, the data
@@ -753,8 +761,12 @@ as for reactions, and the window holds the opposite. Each node's charge balance
 Gauss's law averaged across the section, $`-\partial_x(\varepsilon\,\partial_x\phi) = \rho + a\sigma`$,
 and at $`\varepsilon = 0`$ neutrality $`\rho + a\sigma = 0`$, the mobile species rearranging to supply
 it (counter-ions in, co-ions out). The port passes the charging current, $`d(\int a\sigma\,dV)/dt`$,
-none in a steady state. Capacitances on overlapping windows add (a channel's top and bottom
-gates). A capacitance alone, driven by a current, only charges: it starts uncharged, `advance()`
+none in a steady state. `zeroCharge` is in the frame a contact's is (see the capacitive contact
+above): $`V - \phi`$ at zero charge, with $`\phi`$ the device's own, which a bath or contact sets
+(beside a bath referenced to Cl⁻, with the library's μ°, it sits near −1.4 V). Omitted, it's 0, so
+a port held at V = 0 there starts charged by 1.4 V; to start it uncharged, give `zeroCharge` = V −
+φ at its window (`sol.phi` after a solve). Capacitances on overlapping windows add (a channel's
+top and bottom gates). A capacitance alone, driven by a current, only charges: it starts uncharged, `advance()`
 follows it, and `solve()` refuses (there's no steady state, as for a gate contact driven by one).
 
 ```js nocheck
@@ -1004,14 +1016,19 @@ const now = dev.solution();                   // snapshot of the current state
   as a transient slows, so give `dtMax` to resolve a signal in time.
 - `impedance(frequencies, { terminal, profiles })` solves the steady state, then linearises about
   it: $`Z(f) = \delta V/\delta I`$ in Ω·m² at one terminal (`'right'` by default), with I into the
-  device. A held terminal's voltage is perturbed, or a driven one's current; the other terminals
+  device, its input impedance whether it's held or driven by a current (for a driven one, about
+  the state its drive holds: solve() it held, then set its I, solve(), then impedance()); the other terminals
   keep their drives (held ones at AC ground, driven ones open), so at least one other must be held
   for the current to return (with every other one driven, the impedance is infinite, and an error
   says to measure at a driven one). A terminal behind a resistance can't be the one measured: the
   resistance belongs to the external circuit. The grid must resolve how far the signal reaches,
   and nothing warns of it: in a porous electrode, $`\sqrt{\kappa/(\omega C a)}`$ (cells of 2 µm
   against a 3.4 µm depth put Z 7% off, falling as the cells do; at an electrode, the diffusion
-  length $`\sqrt{2D/\omega}`$ at the highest frequency). The result is `{ f, Z: { re, im },
+  length $`\sqrt{2D/\omega}`$ at the highest frequency, and coarser than that, a port's window
+  edges falling mid-cell moved a faradaic C 17%); and a double layer's capacitance wants cells
+  well inside its Debye length (0.1 M NaCl: hmin λ_D/2.4 read C_dl 2.1% low, 0.1 nm 0.5%, 0.05 nm
+  to 5e-4; the warning about unresolved double layers starts only at λ_D). `relError` is the
+  round-off's, not the grid's. The result is `{ f, Z: { re, im },
   relError, warnings }`: `relError[k]`, each Z's estimated error relative to $`|Z|`$ (from
   round-off in the current and the solves' residuals, and cautious: it can exceed the true error
   many times), and the warnings, the steady state's and one where a Z isn't resolved (an error
@@ -1022,7 +1039,10 @@ const now = dev.solution();                   // snapshot of the current state
   terminal is driven by a current.
 - `set(patch)` merges plain objects deeply (arrays are replaced), except that a contact given `V`
   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
+  switches it to open circuit, whether it was held or behind a resistance. Given `V` alone, a terminal
+  behind a resistance stays behind it: `{ V, R: undefined }` takes the resistance off (`R: 0` and
+  `null` are refused, and `undefined` doesn't survive JSON, so a worker's patch says it this way in
+  JavaScript). 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

package/docs/numerics.md

@@ -661,10 +661,16 @@ About a steady state, a small sinusoidal excitation at one terminal gives, to fi
   $`v \cdot K`$, displacement), and likewise $`C`$ and $`C'`$ for the terminal currents. The
   time-derivative parts are read off two assemblies, $`J(dt) = J + M/dt`$, with a tiny $`dt`$ so that
   the subtraction loses nothing.
-- **At the measured terminal $`T`$,** a held voltage is perturbed ($`\delta V_T = 1`$, and $`\delta I_T`$
-  read from its $`C`$ row), or a driven current ($`\delta I_T = 1`$, and $`\delta V_T`$ solved for).
-  $`Z = \delta V_T/\delta I_T`$, with $`I`$ into the device. The other terminals keep their drives:
-  held ones at AC ground, driven ones open.
+- **At the measured terminal $`T`$,** its voltage is perturbed ($`\delta V_T = 1`$) and
+  $`\delta I_T`$ read, held or driven by a current alike: $`Z = \delta V_T/\delta I_T`$ is its input
+  impedance either way, with $`I`$ into the device. (Solving a driven one's $`\delta V_T`$ for a unit
+  current instead read its current through its own circuit row, at the contact alone: a reverse
+  diode's 4.3% off $`dV/dI`$.) The other terminals keep their drives: held ones at AC ground,
+  driven ones open. A floating one's circuit row reads its current where that reading's error is
+  least: at its contact, or at any cut between it and a port's window, the same current (through a
+  metal it's the round-off of $`G\,\Delta\eta`$); and where every terminal but $`T`$ floats, the
+  response to $`T`$ with them held (nearly every level shifted alike, its current a difference of
+  large terms) is read through the identity that shifting every terminal alike passes nothing.
 
 Each frequency costs one complex block-Thomas factorisation (rows scaled by their largest
 entry), plus one back-substitution per floating terminal for the bordering. Conserved (blocked)

package/docs/reliability.md

@@ -97,7 +97,7 @@ recipes.
 
 The validation suite shows driftlet is right where it converges. Whether it converges, on
 devices nobody tuned it for, is what `npm run stress` tests. It builds random but plausible
-devices in five families:
+devices in six families:
 
 | Family | What's drawn |
 |---|---|
@@ -105,6 +105,7 @@ devices in five families:
 | MOS capacitors | Si, Ge or GaAs, doped 1e15–1e18 cm⁻³; oxide 1–20 nm; Au, Al or Pt gate at any flat-band offset; with or without generation |
 | Electrolyte cells | one to three salts from the data library's ions, 0.1 mM–1 M, 1 µm–1 mm; double layers resolved or strictly neutral; bath, reversible or blocking electrodes |
 | Electrodes | Ag, Cu or Zn deposition, or Fe³⁺/Fe²⁺ on platinum, with Butler–Volmer kinetics over four decades of k₀; with or without a supporting salt; against a second electrode or a bath |
+| Reacting solutions | complexations (Na⁺ + A⁻ = NaA, B + A⁻ = BA⁻, …) in 2–3 regions whose faces block some species, so conserved combinations overlap; against a bath, another bath, closed or a K⁺ electrode; sometimes an electrode at no current reducing a closed M⁺ |
 | Liquid junctions | two mixed solutions, 1 µM–1 M, sharp or graded, at open circuit |
 
 Each device goes through what a user would do with it: a cold solve at no bias, and one at a
@@ -114,26 +115,30 @@ after a voltage step; and the impedance about equilibrium, from far below its sl
 to 1 GHz. Every result is judged by `check()`, and by what must hold whatever the device:
 levels flat at equilibrium with no current, warm and cold solves agreeing, the current driven
 being the one passed, the impedance passive (to 1e-3 of |Z|) and, at low frequency, equal to
-the steady dI/dV, a MOS capacitance never above its oxide's, and its gate charge with the back
+the steady dI/dV where it says it's resolved (`relError` under 1%), a MOS capacitance never above its oxide's, and its gate charge with the back
 contact moved what it is with the gate moved the other way. Each case is seeded from its family and index, so
 any failure reruns alone (`npm run stress -- semi 79`).
 
-At 500 devices per family (about three minutes on a desktop), 11,880 of 11,881 scenarios pass:
+At 500 devices per family (about five minutes on a desktop), 16,379 of 16,381 scenarios pass:
 
-| Family | Cold at 0 V | Cold at bias | Warm sweep | Open circuit, current or back contact | Transient | Impedance |
-|---|---|---|---|---|---|---|
-| Semiconductor stacks | 500/500 | 500/500 | 500/500 | 105/105 | 500/500 | 395/395 |
-| MOS capacitors | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
-| Electrolyte cells | 500/500 | 500/500 | 500/500 | | 500/500 | 381/381 |
-| Electrodes | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
-| Liquid junctions | | | | 500/500 | 499/500 | |
+| Family | Cold at 0 V | Cold at bias | Species reversed | Warm sweep | Open circuit, current or back contact | Transient | Impedance |
+|---|---|---|---|---|---|---|---|
+| Semiconductor stacks | 500/500 | 500/500 | 500/500 | 499/500 | 105/105 | 500/500 | 395/395 |
+| MOS capacitors | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
+| Electrolyte cells | 500/500 | 500/500 | 500/500 | 500/500 |  | 500/500 | 381/381 |
+| Electrodes | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
+| Reacting solutions | 500/500 | 500/500 | 500/500 | 500/500 |  | 500/500 |  |
+| Liquid junctions |  |  |  |  | 500/500 | 499/500 |  |
 
 (Impedance only where the device has an equilibrium to linearise about; open circuit only for
 lit cells.) The MOS back contact came last: before steady solves held a group of reacting
 carriers flat where it reaches one contact alone, 43 of the 500 failed it, 5 of them silently
-(a gate charge up to 2× off). The one that fails is among the known limits below: a junction on a grid far too
-coarse for its double layers.
-`bench/stress.json` keeps the summary.
+(a gate charge up to 2× off). Of the two that fail, one is among the known limits below, a junction on a grid far too
+coarse for its double layers; the other is a diode whose current, a small difference of large fluxes, a warm sweep
+reaches to 1.8e-6 of what a cold solve does, against the 1e-6 the check asks: Newton's tolerance, not the physics
+(its own current varies 2.8e-6 along the device, its balances converged).
+`bench/stress.json` keeps the summary, and CI runs `npm run stress -- --check` against it: any
+scenario failing that passes there fails the build.
 
 Most of what driftlet's numerics do differently began as a failure here: the impedance's
 current read across the quietest cut of the device rather than at the contact, GMRES judged by

package/docs/statistics.md

@@ -73,6 +73,19 @@ of exponentially. With one species it's Langmuir filling of sites. The dilute re
 $`c_{\mathrm{ref}}`$ is kept. To use the half-filling convention of site models
 ($`e^\zeta = x/(1-x)`$), set `cRef` equal to `cMax`.
 
+`cMax` from an ion's size: a cube of side $`a`$ per site gives $`c_{\mathrm{max}} = 1/(N_A a^3)`$, so
+$`a`$ = 0.66 nm (a hydrated ion, about) is 5.8 M, and 0.5 nm is 13 M. The model counts sites only:
+D falling with concentration, solvent counterflow and ion pairing are left out. On a material from
+`aqueous()`, add it to the material it returns:
+
+```js
+import { AVOGADRO } from 'driftlet';
+import { aqueous } from 'driftlet/kit';
+
+const aq = aqueous(['Cu2+', 'SO42-', 'H+']);
+aq.materials.water.statistics = [{ type: 'lattice', species: ['Cu2+', 'SO42-', 'H+'], cMax: 1 / (AVOGADRO * 0.66e-9 ** 3) }];
+```
+
 ### Redlich–Kister
 
 One species on its own $`c_{\mathrm{max}}`$ sites, with the excess Gibbs energy of mixing per site

package/llms.txt

@@ -30,9 +30,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@1.3.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at the end.
@@ -219,9 +219,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@1.3.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.2/src/plot.js';
 
 const def = build({
   T: 300,
@@ -317,6 +317,8 @@ const mos = (Vg, zeroCharge) =>
       layer('Si', units.um(1), { name: 'Si', acceptors: NA }),
       ohmic(0),
     ],
+    // The inversion layer's supply: with it, the low-frequency C–V at every frequency, even
+    // impedance at 1 MHz. Leave it out for the high-frequency curve (see below the code).
     ports: [{ name: 'channel', region: 'Si', from: 0, to: units.nm(1), V: 0, terminal: 'e-', species: { 'e-': 'equilibrium' } }],
     grid: { hmin: units.nm(0.25), hmax: units.nm(50), ratio: 1.15 },
   });
@@ -383,8 +385,9 @@ electrons' V minus φ in the bulk (with the library's μ°), and a Cl⁻ termina
 that, so an electrode held at 0 V beside it is strongly anodic: `describe(def)` says where SHE
 sits, and an offset of that much (`bath(c, 'Cl-', 0, { offset })`) makes the terminal read SHE.
 The working electrode's current is positive when oxidising. The layer's resistance is in series
-(uncompensated IR: keep it thin, or the supporting salt strong); a 100:1 excess of salt still
-leaves the limiting current about 1% off pure diffusion.
+(uncompensated IR: keep it thin, or the supporting salt strong); a 100:1 excess of a 1:1 salt
+still leaves the limiting current about 1% off pure diffusion, and migration counts for more with
+more charge: Cu²⁺ in 1 M H₂SO₄ (20:1) reads 3% above it, with no acid 2×.
 
 ```js
 import { Device, GAS_CONSTANT, FARADAY } from 'driftlet';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for semiconductors, electrochemistry and nerves, fast enough for live web demos",
   "type": "module",
   "exports": {

package/src/describe.js

@@ -114,6 +114,8 @@ export function unitWarnings(def) {
     if (!isObject(p)) return;
     capacitance(`ports[${k}].capacitance.C`, p.capacitance?.C);
     kinetics(`ports[${k}]`, p.reactions);
+    // (an area per volume typed in cm²/cm³ is 100 times too small: a mesh at 10 cm²/cm³ went by)
+    if (typeof p.area === 'number' && p.area > 0 && p.area < 100) warn(`ports[${k}].area`, `${num(p.area)} m²/m³ is under 1 cm² of electrode per cm³; area is m²/m³ (1 cm²/cm³ = 100 m²/m³)`);
   });
   for (const side of ['left', 'right']) {
     const c = def.contacts?.[side];

package/src/impedance.js

@@ -22,33 +22,44 @@
 //   → { f, Z: { re, im }, relError, profiles? }, Z in Ω·m² (Ω for a non-planar device) at each
 //   frequency.
 //   Throws a SolverError where the terminal doesn't exist, has a series resistance, or every
-//   other terminal is driven by a current (no return path: Z infinite), or where a frequency
-//   isn't positive and finite.
+//   other terminal is driven by a current (no return path: Z infinite), where a frequency
+//   isn't positive and finite, or where the linearised system is singular at one.
 //   Linearised about the present state: (J + iωS)·δx + Σ_k B_k δV_k = 0 for the grid's rows and,
 //   for each floating terminal k (driven by a current), (C_k + iωC′_k)·δx + (DI_k + iωDI′_k) δV_k
 //   + Σ_k2 (DX + iωDX′)_k,k2 δV_k2 = δI_k, with J the steady Jacobian (dt = ∞) and S, C′, DI′,
-//   DX′ the storage parts, (X(dt) − X(∞))·dt at dt = 1e-30. A floating terminal that alone feeds
+//   DX′ the storage parts, (X(dt) − X(∞))·dt at dt = 1e-30. The measured terminal is always
+//   excited by its voltage: driven by a current, it's measured as if held (δV = 1, Z = 1/δI, the
+//   same input impedance), its circuit row out of the small system, its current read as a held
+//   one's (with its circuit law's change where it has one); its profiles then scaled by Z, per
+//   unit current. A floating terminal that alone feeds
 //   a conserved combination (a circuit law: a constraint or time law with its circuit row) has
 //   its current read by that combination's change at every frequency, iω F δS/λ plus what a
-//   resistance passes: at dt = 1e-30 every circuit law reads by the change (this.lawForm), and
-//   its steady parts are C = 0, DI = 1/R (0 driven by a current), DX = 0. The measured terminal: held at a
-//   voltage, δV = 1 and Z = 1/δI, δI its current into the device; driven by a current, δI = 1
-//   and Z = δV. Every other terminal keeps its drive: held, δV = 0 (AC ground); driven, δI = 0
-//   (AC open).
+//   resistance passes: at dt = 1e-30 every circuit law with a current to count (λ set) reads by
+//   the change (this.lawForm), and
+//   its steady parts are C = 0, DI = 1/R (0 driven by a current), DX = 0. δI is the measured
+//   terminal's current into the device. Every other terminal keeps its drive: held, δV = 0 (AC
+//   ground); driven, δI = 0 (AC open).
 //   Each frequency: J + iωS with each row divided by its largest entry, factorised, preconditions
 //   GMRES (m 12, 8 restarts, tol 1e-8; its best iterate kept) on the exact J·v (difference form).
-//   Solved: y, the response with the floating terminals held (to the measured one's δV, or none),
+//   A floating contact otherwise reads its current, in its circuit row, at the reading of least
+//   error by the solved responses (its own, or any cut between it and a port's window: the same
+//   current); and where every other terminal floats, a reading with no direct V dependence (a
+//   cut's, a law's change) reads y as Σ X_b, every terminal's uniform shift passing nothing.
+//   Solved: y, the response with the floating terminals held (to the measured one's δV = 1),
 //   and X_k, to each floating terminal's unit δV_k; then the floating terminals' rows, a small
 //   complex system, for their δV; δx = y − Σ X_k δV_k.
 //   The current read (held terminal): DI + iωDI′ + Σ (DX + iωDX′) δV + (C + iωC′)·δx, its error
-//   estimated from its terms' round-off and the solves' residuals; for a contact, also across
+//   estimated from its terms' round-off, the solves' residuals, and each unknown's round-off in
+//   its own row, ε Σ_k |A_jk x_k| / |A_jj| (a metal's current unknown, G Δη to a huge G: a
+//   bound, cautious where the coupled system pins it better); for a contact, also across
 //   each cut (_currentCuts: a segment's linearised total current, conduction and displacement,
 //   between that contact and the nearest port's window where there are ports), the reading with
 //   the least error taken; and where every other terminal floats, by Kirchhoff, Σ δV_k/R_k over
 //   those behind a resistance, its error (ε + the solves' residual)·|δV_k|/R_k. With no floating
 //   terminal, cuts, and that error over 1% of the current:
 //   the response split into each region's uniform shift (_regionShift) and a remainder solved to
-//   GMRES's floor, the shift's effect taken only at the rows it can touch (_regionEdgeRows), and
+//   GMRES's floor, the shift's effect taken only at the rows it can touch (_regionEdgeRows; a
+//   metal's carriers shifted, its current unknown not), and
 //   that reading kept where its error is less.
 //   relError: per frequency, the chosen reading's error estimate over |δI| (held); driven, the
 //   same estimate of its unit current read back from δx. Cautious: it can exceed the true error
@@ -75,8 +86,7 @@
 // Also written, left as the last assembly at dt = ∞ left them: this.sourceTime (the present
 // time), cOld, thOld, th0Old, gateOld (the present state's), contactDStart, portQStart, the
 // residual, the Jacobian and the terminal terms, sysRest and the concentrations; this.lawForm
-// (every circuit law by the change, until a step sets it afresh). _regionShift treats every
-// node's slot 0 as φ̂, a metal's flux unknown too: harmless while a metal region is one cell.
+// (every circuit law by the change, until a step sets it afresh).
 // Tests: test/impedance.test.js (Macdonald's blocking electrodes, a junction's depletion
 // capacitance, a MOS capacitor at both terminals, ports, profiles, Fermi–Dirac against
 // Boltzmann); the demos' EIS.
@@ -218,8 +228,8 @@ export class SmallSignal {
    * gives (J + iωM)·δx + Σ B_k δV_k = rhs for the grid's rows, and (C_k + iωC′_k)·δx +
    * (∂I_k/∂V_k)·δV_k = δI_set,k for each floating terminal's circuit row, with J the steady
    * Jacobian and M the storage part (from J(dt) = J + M/dt), B_k = ∂res/∂V_k and C_k = ∂I_k/∂x.
-   * At the measured terminal, a held voltage is perturbed (rhs = −B δV) and its current read
-   * from C, or a driven current is perturbed and its voltage solved for. The other terminals
+   * At the measured terminal, its voltage is perturbed (rhs = −B δV) and its current read, held
+   * or driven by a current alike (one input impedance; see the contract). The other terminals
    * keep their drives: held ones at AC ground, driven ones at AC open circuit.
    * Z = δV/δI with I into the device (positive real part for a passive device).
    * @param {ArrayLike<number>} frequencies Hz
@@ -249,8 +259,14 @@ export class SmallSignal {
           `its impedance is infinite. Measure at one of those instead (impedance(f, { terminal: '${others[0].name}' }), its voltage against '${terminal}'), or hold one of them at a voltage`,
       );
     }
-    const N = nB * M, fl = this.floating, K = fl.length;
-    const kirchhoff = dT.kind === 'V' && others.every((t) => t.drive.kind === 'I' || t.drive.R > 0);
+    // Z is the device's input impedance at kT, the same whether its voltage is perturbed and its
+    // current read or the other way round. A terminal driven by a current is measured as if held
+    // (δV = 1, Z = 1/δI) to read that current as a held one's is (cuts, Kirchhoff, a circuit law's
+    // change): read through its own circuit row instead, at its contact alone, it was a metal's or
+    // a barrier's round-off (a reverse-biased diode's contact 4.3% off dV/dI; a Schottky
+    // contact's Re Z −32 for 1282), with an error estimate that never saw it.
+    const N = nB * M, fl = this.floating.filter((k) => k !== kT), K = fl.length;
+    const kirchhoff = others.every((t) => t.drive.kind === 'I' || t.drive.R > 0);
     this.sourceTime = this.time;
     this.computeConcentrations();
     this.cOld.set(this.c);
@@ -271,11 +287,14 @@ export class SmallSignal {
     // flux at dt = ∞ and by the change at dt = 1e-30, a floating gate's current was counted
     // twice (its capacitance 2× dQ/dV); read by the flux throughout, through a metal it is the
     // round-off of G Δη (a gate behind 1 kΩ·m², measured at the back contact: Re Z = −2.7).
-    this.lawForm = new Map([...this.constraints, ...this.timeLaws].map((cs) => [cs, true]));
+    // (A law that counts no current, λ unset, as for a terminal at no current that feeds
+    // nothing, can't be read by its change: forced to, a closed Fe³⁺/Fe²⁺ cell's Z was NaN.)
+    const byChange = (cs) => cs.circuit >= 0 && !(cs.contacts?.length > 0) && Number.isFinite(cs.lambda) && cs.lambda !== 0;
+    this.lawForm = new Map([...this.constraints, ...this.timeLaws].map((cs) => [cs, byChange(cs)]));
     this.assemble(dts);
     for (const cs of [...this.constraints, ...this.timeLaws]) {
       const k = cs.circuit;
-      if (k < 0 || !fl.includes(k) || cs.contacts?.length > 0) continue;
+      if (!byChange(cs) || !(fl.includes(k) || (k === kT && dT.kind === 'I'))) continue;
       Ct[k].fill(0);
       DI[k] = this.terms[k].drive.R > 0 ? 1 / this.terms[k].drive.R : 0;
       DX[k].fill(0);
@@ -288,11 +307,31 @@ export class SmallSignal {
     // Where the measured contact's current may be read across a segment: anywhere without
     // ports; with them, only between it and the nearest window (a port's exchange takes current
     // in or out along it). Never for a port's own terminal.
-    let cuts = kT < 2 ? this._currentCuts() : null;
-    if (cuts && this.model.ports.length > 0) {
-      const windows = this.model.ports.flatMap((p) => Array.from(p.nodes));
-      const lo = Math.min(...windows), hi = Math.max(...windows);
-      cuts = cuts.filter((cut) => (kT === 0 ? cut.s + 1 <= lo : cut.s >= hi));
+    const allCuts = this._currentCuts(), windows = this.model.ports.flatMap((p) => Array.from(p.nodes));
+    const lo = windows.length ? Math.min(...windows) : Infinity, hi = windows.length ? Math.max(...windows) : -Infinity;
+    const cutsOf = (k) => allCuts.filter((cut) => (k === 0 ? cut.s + 1 <= lo : cut.s >= hi));
+    const cuts = kT < 2 ? cutsOf(kT) : null;
+    // A floating contact on a metal: its circuit row's current through the metal is the current
+    // unknown G Δη, round-off to a huge G (a Pt electrode behind 3000 Ω·m², read at the bath: Z −
+    // R came out 70.5 for 3070.5). Any cut between it and a port's window carries the same current
+    // (a metal stores none; the total current is continuous through its face), so each frequency
+    // reads it where its error, by the solved responses, is least (see readings, below).
+    const lawRead = new Set([...this.constraints, ...this.timeLaws].filter(byChange).map((cs) => cs.circuit));
+    const choices = new Map(); // k → [{ c, cs, di, dis, dx, dxs }]: its own reading, then each cut's
+    for (const k of fl) {
+      if (k > 1 || lawRead.has(k)) continue;
+      const own = { c: Ct[k].slice(), cs: Cs[k].slice(), di: DI[k], dis: DIs[k], dx: DX[k].slice(), dxs: DXs[k].slice() }, list = [own];
+      const sgn = k === 0 ? 1 : -1, R = this.terms[k].drive.R;
+      for (const cut of cutsOf(k)) {
+        const c = new Float64Array(own.c.length), cs = new Float64Array(own.c.length);
+        cut.idx.forEach((x, a) => {
+          if (this.rix[x] >= this.sys.size) return;
+          c[this.rix[x]] += sgn * cut.g[a];
+          cs[this.rix[x]] += sgn * cut.d[a];
+        });
+        list.push({ c, cs, di: R > 0 ? 1 / R : 0, dis: 0, dx: new Float64Array(own.dx.length), dxs: new Float64Array(own.dx.length) });
+      }
+      if (list.length > 1) choices.set(k, list);
     }
     // J·v for GMRES, exact: the assembled J holds a flux's dependence on η_L and η_R as two
     // entries, and where both are huge (an inversion layer) and v nearly uniform, J·v loses the
@@ -348,7 +387,12 @@ export class SmallSignal {
           }
         }
       }
-      csys.factor();
+      try {
+        csys.factor();
+      } catch (err) {
+        // (it threw a bare Error, its block number all it said: a cell 2.8 V off its pzc)
+        throw new SolverError(`impedance: the linearised equations are singular at ${f} Hz (${err.message}): some part of the device is held by nothing at that frequency, as a double layer far from where it balances can leave it. See the steady state's warnings (solve()).`);
+      }
       const sx = (X, vr, out) => {
         for (let blk = 0; blk < nB; blk++) {
           const m = sizes[blk], mp = blk > 0 ? sizes[blk - 1] : 0, mn = blk < nB - 1 ? sizes[blk + 1] : 0;
@@ -404,24 +448,77 @@ export class SmallSignal {
       };
       let accuracy = 1e-14; // (relative, of the solves: the readouts' error is weighed with it)
       // y: the response with the floating terminals held; X_k: to a unit δV_k.
-      const heldT = dT.kind === 'V';
       for (let j = 0; j < Nc; j++) {
-        rr[j] = heldT ? -Bt[kT][j] * scale[j] : 0;
+        rr[j] = -Bt[kT][j] * scale[j];
         ri[j] = 0;
       }
-      solve(rr, ri, yr, yi, heldT ? kT : -1, heldT ? 1 : 0);
+      solve(rr, ri, yr, yi, kT, 1);
       fl.forEach((k, a) => {
         for (let j = 0; j < Nc; j++) rr[j] = Bt[k][j] * scale[j];
         ri.fill(0);
         solve(rr, ri, Xr[a], Xi[a], k, -1);
       });
+      // Each unknown's round-off in its own row: |x_j| to ε Σ_k |A_jk x_k| / |A_jj|, A = J + iωS. A
+      // metal's current unknown, G Δη to a huge G, is known only to ε G |δη| this way, which the
+      // terms' round-off alone never saw (a platinum electrode's current read 20% off at 1 nHz,
+      // its estimate 1e-8).
+      const rowFloor = (xr0, xi0) => {
+        const out = new Float64Array(Nc);
+        for (let blk = 0; blk < nB; blk++) {
+          const m = sizes[blk], mp = blk > 0 ? sizes[blk - 1] : 0, mn = blk < nB - 1 ? sizes[blk + 1] : 0;
+          for (let r = 0; r < m; r++) {
+            let acc = 0;
+            const row = (X, o, len, x0) => {
+              for (let cc = 0; cc < len; cc++) acc += (Math.abs(J[X][o + cc]) + w * Math.abs(S[X][o + cc])) * Math.hypot(xr0[x0 + cc], xi0[x0 + cc]);
+            };
+            if (mp) row('A', offA[blk] + r * mp, mp, offX[blk - 1]);
+            row('B', offB[blk] + r * m, m, offX[blk]);
+            if (mn) row('C', offC[blk] + r * mn, mn, offX[blk + 1]);
+            const dIdx = offB[blk] + r * m + r, diag = Math.hypot(J.B[dIdx], w * S.B[dIdx]);
+            out[offX[blk] + r] = diag > 0 ? (1.1e-16 * acc) / diag : 0;
+          }
+        }
+        return out;
+      };
+      // Each floating metal contact's reading, of those it can take, with the least error by the
+      // solved responses (their terms' round-off and each unknown's in its own row).
+      const gaugeRead = new Set(lawRead); // (readings with no direct dependence on any V: see y below)
+      if (choices.size) {
+        const eps = 1.1e-16, parts = [[yr, yi], ...fl.map((_, b) => [Xr[b], Xi[b]])];
+        const mag = new Float64Array(Nc), floor = new Float64Array(Nc);
+        for (const [pr, pi] of parts) {
+          const rf = rowFloor(pr, pi);
+          for (let j = 0; j < Nc; j++) {
+            mag[j] += Math.hypot(pr[j], pi[j]);
+            floor[j] += rf[j];
+          }
+        }
+        for (const [k, list] of choices) {
+          let best = null, least = Infinity;
+          for (const r of list) {
+            let e = eps * (Math.abs(r.di) + w * Math.abs(r.dis));
+            for (let j = 0; j < Nc; j++) e += (Math.abs(r.c[j]) + w * Math.abs(r.cs[j])) * (eps * mag[j] + floor[j]);
+            if (e < least) [best, least] = [r, e];
+          }
+          if (best !== list[0]) gaugeRead.add(k);
+          Ct[k].set(best.c);
+          Cs[k].set(best.cs);
+          DI[k] = best.di;
+          DIs[k] = best.dis;
+          DX[k].set(best.dx);
+          DXs[k].set(best.dxs);
+        }
+      }
       // The floating terminals' circuit rows, a small complex system for their δV.
       const Ar = Array.from({ length: K }, () => new Float64Array(K + 1)), Ai = Array.from({ length: K }, () => new Float64Array(K + 1));
       fl.forEach((k, a) => {
+        let sre = 0, sim = 0;
         for (let b = 0; b < K; b++) {
           const [re, im] = dot(k, w, Xr[b], Xi[b]);
           Ar[a][b] = -re;
           Ai[a][b] = -im;
+          sre += re;
+          sim += im;
         }
         Ar[a][a] += DI[k];
         Ai[a][a] += w * DIs[k];
@@ -432,9 +529,14 @@ export class SmallSignal {
           Ar[a][b] += DX[k][k2];
           Ai[a][b] += w * DXs[k][k2];
         });
-        const [yre, yim] = dot(k, w, yr, yi);
-        Ar[a][K] = (k === kT ? 1 : 0) - yre - (heldT ? DX[k][kT] : 0);
-        Ai[a][K] = -yim - (heldT ? w * DXs[k][kT] : 0);
+        // Every terminal shifted alike moves nothing and passes no current, and y + Σ (−X_b) is
+        // that shift where kT and the floating terminals are all there are: so a reading with
+        // no direct dependence on a V reads y as Σ X_b, exactly, from responses it resolves, where
+        // y itself is nearly that shift and its current a difference of them (a Pt electrode
+        // behind 3000 Ω·m², at 1 nHz: its cuts read y 10% apart).
+        const [yre, yim] = kirchhoff && gaugeRead.has(k) ? [sre, sim] : dot(k, w, yr, yi);
+        Ar[a][K] = -yre - DX[k][kT];
+        Ai[a][K] = -yim - w * DXs[k][kT];
       });
       const dV = complexSolve(Ar, Ai, K);
       // δx = y − Σ X_k δV_k
@@ -475,7 +577,8 @@ export class SmallSignal {
           const [re, im] = dot(kT, w, p.r, p.i);
           Ir += re;
           Ii += im;
-          for (let j = 0; j < Nc; j++) err += (Math.abs(c[j]) + w * Math.abs(cs[j])) * (eps * Math.hypot(p.r[j], p.i[j]) + p.floor);
+          p.rf ??= rowFloor(p.r, p.i);
+          for (let j = 0; j < Nc; j++) err += (Math.abs(c[j]) + w * Math.abs(cs[j])) * (eps * Math.hypot(p.r[j], p.i[j]) + p.floor + p.rf[j]);
         }
         // Kirchhoff, where every other terminal floats: what they pass comes back through kT,
         // δI = Σ δV_k/R_k over those behind a resistance (one driven by a current passes no small
@@ -503,7 +606,7 @@ export class SmallSignal {
               // (g + iωd)(xr + i xi)
               re += gk * p.fr[x] - dk * p.fi[x];
               im += gk * p.fi[x] + dk * p.fr[x];
-              e += (Math.abs(gk) + Math.abs(dk)) * (eps * Math.hypot(p.fr[x], p.fi[x]) + p.floor);
+              e += (Math.abs(gk) + Math.abs(dk)) * (eps * Math.hypot(p.fr[x], p.fi[x]) + p.floor + (this.rix[x] < Nc ? p.rf[this.rix[x]] : 0));
             }
           }
           if (e < err) [err, Ir, Ii] = [e, sgn * re, sgn * im];
@@ -524,7 +627,7 @@ export class SmallSignal {
         return [fr, fi];
       };
       let Zr, Zi;
-      if (heldT) {
+      {
         // δI per volt: (C + iωC′)·δx + (∂I/∂V)(1 + iω′) at the terminal…
         let { Ir, Ii, err } = read([{ r: yr, i: yi, fr: xr, fi: xi, floor: accuracy * largest(yr, yi) }]);
         // …and where the solves leave that unresolved (the estimate past 1% of the current), the
@@ -565,14 +668,10 @@ export class SmallSignal {
         const d2 = Ir * Ir + Ii * Ii; // Z = 1/δI
         Zr = Ir / d2;
         Zi = -Ii / d2;
-      } else {
-        // δV per unit current; its error as the unit current's, read back from δx, is uncertain
-        // (round-off in the current's terms, and the solves' residuals: see read)
-        const a = fl.indexOf(kT);
-        Zr = dV.re[a];
-        Zi = dV.im[a];
-        const back = read([{ r: yr, i: yi, fr: xr, fi: xi, floor: accuracy * largest(yr, yi) }], [Zr, Zi]);
-        out.relError[q] = back.err / Math.hypot(back.Ir, back.Ii);
+      }
+      // (profiles per unit excitation: for a terminal driven by a current, per A/m², δx·Z)
+      if (profiles && dT.kind === 'I') {
+        for (let j = 0; j < N; j++) [xr[j], xi[j]] = [xr[j] * Zr - xi[j] * Zi, xr[j] * Zi + xi[j] * Zr];
       }
       out.Z.re[q] = Zr;
       out.Z.im[q] = Zi;
@@ -590,9 +689,12 @@ export class SmallSignal {
     for (let r = 0; r < model.regions.length; r++) {
       let sr = 0, si = 0, k = 0;
       const g0 = grid.regionStart[r], g1 = grid.regionEnd[r];
+      // (a metal's slot 0 is its segment's current, not φ̂: shifted, a platinum region of many
+      // cells read its electrode's current 8% off, at an error estimate of 1e-8)
+      const phiAt = (g) => this.nodeConductor[g] < 0 && loc[this.blockOfNode[g] * M] >= 0;
       for (let g = g0; g <= g1; g++) {
         const o = this.blockOfNode[g] * M;
-        if (loc[o] >= 0) {
+        if (phiAt(g)) {
           sr += yr[R[o]];
           si += yi[R[o]];
           k++;
@@ -614,7 +716,7 @@ export class SmallSignal {
       si /= k;
       for (let g = g0; g <= g1; g++) {
         const o = this.blockOfNode[g] * M;
-        if (loc[o] >= 0) {
+        if (phiAt(g)) {
           er[R[o]] = sr;
           ei[R[o]] = si;
         }

package/src/index.js

@@ -132,6 +132,7 @@ export class Device {
       solver.sourceTime = old.sourceTime;
       solver._refreshSources();
       solver.dtNext = old.dtNext;
+      solver.coldStart = old.coldStart; // (a carried state is as cold as it was: see equilibrateFaces)
       solver.contactDEnd = old.contactDEnd;
       if (old.portQEnd?.length === solver.portQ.length) solver.portQEnd = old.portQEnd;
       solver.solvedV = old.solvedV; // where the carried-over state was solved (for continuation)

package/src/newton.js

@@ -75,7 +75,9 @@
 // Also written: s.islandsOn (as asked, or on by 8); s.lostMode, s.accepted (7); s.delta, s.deltaV,
 // s.rowDiv; what an assembly writes, at the returned state where a probe or 6's check ran;
 // s.conditioning (a steady solve's failure: the worst cancellation a factorisation showed, for
-// its message).
+// its message); s.modelError, the message of a SolverError a statistics model threw at a state
+// Newton reached (in the assembly, or computing the concentrations where it stops), which fails
+// the call rather than leaving it (cleared by solveSteady and integrate, for their failures).
 // Tests: every solve and step goes through here; test/newton.test.js (the islands round, the
 // residual check's failure) and the MOS gate step in test/ports.test.js (a lost mode, to 1e-6);
 // test/jacobian.test.js checks the system it solves. The devices that needed each branch are in
@@ -401,6 +403,19 @@ export function newton(s, dt, { maxIter = 60, tol = 1e-10, maxStep = 10, islands
   };
   // A steady solve that fails: record how nearly singular the system was, and where; or, failing
   // with the islands' rows in, go back to the solution without them.
+  // The concentrations at the state Newton stops at, where a statistics model can refuse it (a
+  // Debye–Hückel solution past its range, at the converged state of a transient: the error was
+  // thrown from here, uncaught, out of solve() and advance()). Its message, for the failure.
+  const settle = () => {
+    try {
+      s.computeConcentrations();
+      return null;
+    } catch (err) {
+      if (!(err instanceof SolverError)) throw err;
+      s.modelError = err.message;
+      return err.message;
+    }
+  };
   const fail = (r) => {
     if (kept) {
       s.u.set(kept.u);
@@ -430,6 +445,7 @@ export function newton(s, dt, { maxIter = 60, tol = 1e-10, maxStep = 10, islands
     } catch (err) {
       // A statistics model can fail far from the solution (e.g. Debye–Hückel beyond its range).
       if (!(err instanceof SolverError)) throw err;
+      s.modelError = err.message;
       return fail({ converged: false, iterations: it, history, error: err.message });
     }
     equilibrate(s);
@@ -500,7 +516,8 @@ export function newton(s, dt, { maxIter = 60, tol = 1e-10, maxStep = 10, islands
       const done = { converged: true, iterations: it, history, residual: rmax };
       if (probed()) continue;
       if (islandsOff(it, done)) continue;
-      s.computeConcentrations();
+      const refused = settle();
+      if (refused) return fail({ converged: false, iterations: it, history, error: refused });
       return done;
     }
     // Converged as far as round-off allows: the updates are already tiny (below 1e-6 thermal
@@ -523,12 +540,13 @@ export function newton(s, dt, { maxIter = 60, tol = 1e-10, maxStep = 10, islands
       const done = { converged: true, iterations: it, history, residual: rmax, roundoff: true };
       if (probed()) continue;
       if (islandsOff(it, done)) continue;
-      s.computeConcentrations();
+      const refused = settle();
+      if (refused) return fail({ converged: false, iterations: it, history, error: refused });
       return done;
     }
   }
-  s.computeConcentrations();
-  return fail({ converged: false, iterations: maxIter, history });
+  const refused = settle();
+  return fail({ converged: false, iterations: maxIter, history, ...(refused ? { error: refused } : {}) });
 }
 
 // How far the terminal currents (as last assembled) are from adding up to zero, relative to the

package/src/solution.js

@@ -311,6 +311,11 @@ export function makeSolution(solver, result = {}) {
       `the solve did not converge from a start far from equilibrium: ${solver.violent.join('; ')}, its double layer uncharged. ` +
         'Hold that terminal at a voltage first, solve(), then let it float (set its I: 0): it keeps the state the held one gave it.',
     );
+  } else if (result.converged === false && !result.stopped && !un && !ch && !lost && slow.length === 0 && !(cond && cond.digits > 12) && solver.modelError) {
+    sol.warnings.push(
+      `the solve did not converge: the states it reached were refused by a statistics model: ${solver.modelError}. ` +
+        'The model doesn\'t hold there: a smaller concentration or drive, or a model for it (lattice for crowding).',
+    );
   } else if (result.converged === false && !result.stopped && !un && !ch && !lost && slow.length === 0 && !(cond && cond.digits > 12)) {
     sol.warnings.push(
       'the solve did not converge, and nothing specific showed why. ' +

package/src/solver.js

@@ -291,9 +291,15 @@ export class Solver {
     this.termDX = this.terms.map(() => new Float64Array(this.terms.length));
     this.termRes = new Float64Array(this.terms.length);
     this._refreshSources();
-    // A floating terminal starts level with the first held one (no current).
-    const level = this.termV[this.terms.findIndex((_, k) => !this.floating.includes(k))];
-    for (const k of this.floating) this.termV[k] = this.terms[k].drive.kind === 'V' ? this.termV[k] : level;
+    // A floating terminal starts level with the first held one (no current); where none is held,
+    // with the source behind the first resistance (it was NaN there, and a metal contact's
+    // carrier, its level from that V, asked for a c0 a conductor can't be given), else 0.
+    const heldK = this.terms.findIndex((_, k) => !this.floating.includes(k)), behindR = this.terms.find((t) => t.drive.R > 0);
+    const level = heldK >= 0 ? this.termV[heldK] : behindR ? sourceAt(behindR.drive.src, this.time) : 0;
+    // (One behind a resistance too: at its own source, a silver cell held at 0 V and 16 V behind R
+    // began with 16 V across it; left at 0 V, one behind a −30 V source beside a current began
+    // with 30 V across it. Level, the circuit rows move them from a device at rest.)
+    for (const k of this.floating) this.termV[k] = level;
     // Accepted steps, most recent first: start time, size, start state (for BDF2 and the
     // error estimate of adaptive stepping).
     this.history = [];
@@ -830,6 +836,7 @@ export class Solver {
     }
     this.termV.set(src.termV);
     this.solvedV = src.solvedV;
+    this.coldStart = src.coldStart;
     this.time = src.time;
     this.computeConcentrations();
   }
@@ -855,6 +862,7 @@ export class Solver {
       history: this.history.slice(),
       termV: Float64Array.from(this.termV),
       sourceTime: this.sourceTime,
+      coldStart: this.coldStart,
     };
   }
 
@@ -878,6 +886,7 @@ export class Solver {
     this.history = s.history.slice();
     this.termV.set(s.termV);
     this.sourceTime = s.sourceTime;
+    this.coldStart = s.coldStart;
     this.computeConcentrations();
   }
 

package/src/start.js

@@ -27,18 +27,22 @@
 //      plus each face's dipole. In a region where a level-fixed charged species responds to φ̂,
 //      φ̂ is chosen for neutrality (a bisection; node by node where a profile varies);
 //      otherwise it's the running φ̂, or where a conductor on the left or an electrode spread
-//      through the region has a reaction that can balance, the φ̂ that balances it. Where
+//      through the region has a reaction that can balance, the φ̂ that balances it (by bisection;
+//      a trial a non-ideal model refuses counts its ideal charge, which has the sign there). Where
 //      neutrality is out of reach (c0's amounts leave a charge no held level balances), the
 //      running φ̂, and a strictly neutral region is noted in s.unbalanced (for a transient that
 //      fails from it to say why). A strictly
 //      neutral region (ε = 0) with every charged species' amount given must have a neutral c0:
 //      an error otherwise. A non-ideal material's composition comes from its statistics
 //      (materialAt).
-//   2. A face between two strictly neutral ideal regions, its φ type neutral, whose links hold
-//      some charged species in equilibrium: its two nodes are set to that equilibrium (each
-//      passing species' μ̄ equal across it, the left node neutral, each passing species' amount
-//      over the two nodes kept; the jump in φ̂ between them the one unknown), everything else at
-//      them unchanged in concentration.
+//   2. Marks the state cold (s.coldStart). equilibrateFaces(s), which the first time step from it
+//      calls (src/timeSteps.js) and a steady solve doesn't: a face between two strictly neutral
+//      ideal regions, its φ type neutral, whose links hold some charged species in equilibrium,
+//      its two nodes set to that equilibrium, its t = 0⁺ (each passing species' μ̄ equal across
+//      it, the left node neutral, each passing species' amount over the two nodes kept; the jump
+//      in φ̂ between them the one unknown), everything else at them unchanged in concentration;
+//      s.coldStart false. A solve that converges, a warm start and a carried state set it as
+//      their state is.
 //   3. An insertion host (a φ-free material, not a conductor): its φ̂ and every η shifted by z·Δ so that its first
 //      charged species shared with a neighbour across a face starts at that neighbour's level.
 //   4. A floating contact facing a held one: V = the held V + the difference between the two
@@ -55,8 +59,8 @@
 //      pass the current it's driven at, or behind a resistance (V_src − V)/R, by bisection.
 //
 // Invariants (each says what a reviewer should be able to check here):
-//   1. A species given by its amount starts at c0 (or its profile) at every node, but for the
-//      two nodes of a face equilibrated in step 2, where its amount over the two is kept.
+//   1. A species given by its amount starts at c0 (or its profile) at every node; at a face
+//      equilibrated by step 2 (a transient's first step), its amount over the two nodes is kept.
 //   2. A species given by its level starts at the level of what feeds it, as step 1 orders them.
 //   3. Where a level-fixed charged species responds, each node starts neutral (Σ z c + the fixed
 //      charge = 0) to the bisection's tolerance, unless neutrality is out of reach (step 1); a
@@ -65,7 +69,7 @@
 //      z·Δ), step 2 moves the passing species between a face's two nodes only.
 //   5. Each floating terminal's V is set by the last of steps 4, 6, 7, 9 that applies to it;
 //      held terminals' V are untouched.
-//   6. Only u, uLo, termV, s.unbalanced and what computeConcentrations derives are written; the
+//   6. Only u, uLo, termV, s.unbalanced, s.coldStart and what computeConcentrations derives are written; the
 //      result depends on the model, every terminal's voltage and s.time, deterministically.
 // Known, and not an invariant (a cold review; see ROADMAP): the gauge (φ̂ and each η by z·Δ)
 // runs from the left, so behind a closed or floating left end the start sits away from a right
@@ -163,10 +167,22 @@ export function initFromComposition(s) {
     const zeta = new Float64Array(n), cc = new Float64Array(n);
     const charge = (ph) => {
       if (!mat.ideal) {
-        materialAt(s, mat, reg.background, eta, mode, cFix, ph, zeta, cc);
-        let q = reg.fixedCharge / FARADAY;
-        for (let i = 0; i < n; i++) if (mat.present[i]) q += z[i] * cc[i];
-        return q;
+        // A model can refuse a trial φ̂ far out, where one ion is many orders denser than the rest
+        // (Debye–Hückel's limiting law threw out of the start, for KCl at 10 mM, its neutral φ̂
+        // 57 units from where the search began): there the ideal charge has the sign, and the
+        // search goes on by it.
+        let refused = false;
+        try {
+          materialAt(s, mat, reg.background, eta, mode, cFix, ph, zeta, cc);
+        } catch (err) {
+          if (!(err instanceof SolverError)) throw err;
+          refused = true;
+        }
+        if (!refused) {
+          let q = reg.fixedCharge / FARADAY;
+          for (let i = 0; i < n; i++) if (mat.present[i]) q += z[i] * cc[i];
+          return q;
+        }
       }
       let q = reg.fixedCharge / FARADAY;
       for (let i = 0; i < n; i++) {
@@ -279,53 +295,6 @@ export function initFromComposition(s) {
       }
     }
   }
-  // Two strictly neutral regions meeting at a face whose links hold ions in equilibrium: where
-  // c0 leaves the two sides out of it (a different fixed charge or immobile ion on each, so
-  // c₊c₋ differs across it), the face reaches it at t = 0⁺, before anything diffuses, and a
-  // first step made to take that jump met an exactly singular pivot. Start there: the ions the
-  // face passes shared between its two nodes in equilibrium (μ̄ equal across it), each one's
-  // amount over the two nodes kept, everything else as c0 has it. The one unknown is the jump
-  // in φ̂ across it (a Donnan potential), set by neutrality on one side; the other's follows,
-  // the two nodes' charge summing to what it was, zero.
-  for (let f = 0; f < interfaces.length; f++) {
-    const itf = interfaces[f], mL = materials[regions[f].material], mR = materials[regions[f + 1].material];
-    const strict = (m) => m.epsr === 0 && !m.conductor && !m.phiFree && m.ideal;
-    if (itf.phi.type !== 'neutral' || !strict(mL) || !strict(mR)) continue;
-    const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1], bL = s.blockOfNode[gL] * M, bR = s.blockOfNode[gR] * M;
-    const pass = [];
-    for (let i = 0; i < n; i++) if (itf.links[i].type === 'equilibrium' && mL.present[i] && mR.present[i]) pass.push(i);
-    if (!pass.some((i) => z[i] !== 0)) continue;
-    const RT = model.RT, vL = grid.vol[gL], vR = grid.vol[gR];
-    const conc = (m, b, i) => m.cRef[i] * Math.exp(u[b + 1 + i] - m.mu0[i] / RT - z[i] * u[b]);
-    const amount = pass.map((i) => vL * conc(mL, bL, i) + vR * conc(mR, bR, i));
-    let qOther = regions[f].fixedCharge / FARADAY; // (the left node's charge from all it doesn't share)
-    for (let i = 0; i < n; i++) if (mL.present[i] && !pass.includes(i) && z[i] !== 0) qOther += z[i] * conc(mL, bL, i);
-    // At a jump D = φ̂_R − φ̂_L: c_L/c_R = (cRef_L/cRef_R)·exp((μ°_R − μ°_L)/RT + z D), the amount fixing both.
-    const split = (D) =>
-      pass.map((i, j) => {
-        const K = (mL.cRef[i] / mR.cRef[i]) * Math.exp((mR.mu0[i] - mL.mu0[i]) / RT + z[i] * D), cR = amount[j] / (vL * K + vR);
-        return [K * cR, cR];
-      });
-    const qL = (D) => split(D).reduce((q, [cL], j) => q + z[pass[j]] * cL, qOther); // (increasing in D)
-    const D0 = u[bR] - u[bL];
-    let lo = D0 - 1, hi = D0 + 1;
-    while (qL(lo) > 0 && lo > D0 - 1e3) lo -= 2 * (hi - lo);
-    while (qL(hi) < 0 && hi < D0 + 1e3) hi += 2 * (hi - lo);
-    if (!(qL(lo) <= 0 && qL(hi) >= 0)) continue; // (nothing the face shares can balance it: leave c0)
-    for (let it = 0; it < 200 && hi - lo > 1e-13 * Math.max(1, Math.abs(D0)); it++) {
-      const m = 0.5 * (lo + hi);
-      if (qL(m) < 0) lo = m;
-      else hi = m;
-    }
-    const D = 0.5 * (lo + hi), cs = split(D);
-    const keep = Float64Array.from({ length: n }, (_, i) => (mR.present[i] ? conc(mR, bR, i) : 0)); // (the right node's, before φ̂ moves)
-    u[bR] = u[bL] + D;
-    for (let i = 0; i < n; i++) if (mR.present[i] && !pass.includes(i)) u[bR + 1 + i] = Math.log(keep[i] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
-    pass.forEach((i, j) => {
-      u[bL + 1 + i] = Math.log(cs[j][0] / mL.cRef[i]) + mL.mu0[i] / RT + z[i] * u[bL];
-      u[bR + 1 + i] = Math.log(cs[j][1] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
-    });
-  }
   // An insertion host's φ is a gauge: c0 sets only its neutral combination's level, not how that
   // splits between its ion and its electrons. Start its ion level with the same ion's beside it
   // across a face (the equilibrium a link or a transfer reaction heads for), so its electrons,
@@ -447,6 +416,69 @@ export function initFromComposition(s) {
     }
     s.termV[k] = 0.5 * (lo + hi);
   }
+  s.coldStart = true; // (until a solve or a step moves it: see equilibrateFaces)
+}
+
+/**
+ * The t = 0⁺ state at the faces between strictly neutral regions, taken by the first time step
+ * from a cold start (src/timeSteps.js) and not by a steady solve, which needs no t = 0⁺: there it
+ * was the worse start, its face nodes moved while the rest of a region stayed (a stack whose
+ * middle region started 2.2 V from its neighbour's level failed every steady solve, where the
+ * cold start converged in one).
+ */
+export function equilibrateFaces(s) {
+  const { model, n, M, u, z } = s;
+  const { regions, interfaces, materials } = model;
+  const grid = model.grid;
+  s.coldStart = false;
+  // Two strictly neutral regions meeting at a face whose links hold ions in equilibrium: where
+  // c0 leaves the two sides out of it (a different fixed charge or immobile ion on each, so
+  // c₊c₋ differs across it), the face reaches it at t = 0⁺, before anything diffuses, and a
+  // first step made to take that jump met an exactly singular pivot. Start there: the ions the
+  // face passes shared between its two nodes in equilibrium (μ̄ equal across it), each one's
+  // amount over the two nodes kept, everything else as c0 has it. The one unknown is the jump
+  // in φ̂ across it (a Donnan potential), set by neutrality on one side; the other's follows,
+  // the two nodes' charge summing to what it was, zero.
+  for (let f = 0; f < interfaces.length; f++) {
+    const itf = interfaces[f], mL = materials[regions[f].material], mR = materials[regions[f + 1].material];
+    const strict = (m) => m.epsr === 0 && !m.conductor && !m.phiFree && m.ideal;
+    if (itf.phi.type !== 'neutral' || !strict(mL) || !strict(mR)) continue;
+    const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1], bL = s.blockOfNode[gL] * M, bR = s.blockOfNode[gR] * M;
+    const pass = [];
+    for (let i = 0; i < n; i++) if (itf.links[i].type === 'equilibrium' && mL.present[i] && mR.present[i]) pass.push(i);
+    if (!pass.some((i) => z[i] !== 0)) continue;
+    const RT = model.RT, vL = grid.vol[gL], vR = grid.vol[gR];
+    const conc = (m, b, i) => m.cRef[i] * Math.exp(u[b + 1 + i] - m.mu0[i] / RT - z[i] * u[b]);
+    const amount = pass.map((i) => vL * conc(mL, bL, i) + vR * conc(mR, bR, i));
+    let qOther = regions[f].fixedCharge / FARADAY; // (the left node's charge from all it doesn't share)
+    for (let i = 0; i < n; i++) if (mL.present[i] && !pass.includes(i) && z[i] !== 0) qOther += z[i] * conc(mL, bL, i);
+    // At a jump D = φ̂_R − φ̂_L: c_L/c_R = (cRef_L/cRef_R)·exp((μ°_R − μ°_L)/RT + z D), the amount fixing both.
+    const split = (D) =>
+      pass.map((i, j) => {
+        const K = (mL.cRef[i] / mR.cRef[i]) * Math.exp((mR.mu0[i] - mL.mu0[i]) / RT + z[i] * D), cR = amount[j] / (vL * K + vR);
+        return [K * cR, cR];
+      });
+    const qL = (D) => split(D).reduce((q, [cL], j) => q + z[pass[j]] * cL, qOther); // (increasing in D)
+    const D0 = u[bR] - u[bL];
+    let lo = D0 - 1, hi = D0 + 1;
+    while (qL(lo) > 0 && lo > D0 - 1e3) lo -= 2 * (hi - lo);
+    while (qL(hi) < 0 && hi < D0 + 1e3) hi += 2 * (hi - lo);
+    if (!(qL(lo) <= 0 && qL(hi) >= 0)) continue; // (nothing the face shares can balance it: leave c0)
+    for (let it = 0; it < 200 && hi - lo > 1e-13 * Math.max(1, Math.abs(D0)); it++) {
+      const m = 0.5 * (lo + hi);
+      if (qL(m) < 0) lo = m;
+      else hi = m;
+    }
+    const D = 0.5 * (lo + hi), cs = split(D);
+    const keep = Float64Array.from({ length: n }, (_, i) => (mR.present[i] ? conc(mR, bR, i) : 0)); // (the right node's, before φ̂ moves)
+    u[bR] = u[bL] + D;
+    for (let i = 0; i < n; i++) if (mR.present[i] && !pass.includes(i)) u[bR + 1 + i] = Math.log(keep[i] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
+    pass.forEach((i, j) => {
+      u[bL + 1 + i] = Math.log(cs[j][0] / mL.cRef[i]) + mL.mu0[i] / RT + z[i] * u[bL];
+      u[bR + 1 + i] = Math.log(cs[j][1] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
+    });
+  }
+  s.computeConcentrations();
 }
 
 // A non-ideal material's composition at φ̂ = ph: level-fixed species (mode 1) at their η,

package/src/steady.js

@@ -50,7 +50,10 @@
 //      start (initFromComposition), whose u and uLo become the stages' start (termV stays the
 //      start's: a floating terminal keeps the voltage the transient left it at).
 //   2. Continuation: generation ramped up (_generationContinuation); a terminal driven by a
-//      current, not bound (_bound), held at voltages instead (_floatingContinuation); with
+//      terminals behind a resistance held (at their source voltages, or where every other
+//      terminal is driven by a current at V_src − I R, Kirchhoff's I), then the resistances put
+//      back and the steady system solved from there (_resistanceContinuation); a terminal
+//      driven by a current, not bound (_bound), held at voltages instead (_floatingContinuation); with
 //      canContinue, the right contact's voltage ramped to its target (_continuation): from the
 //      voltages of the last converged solve (this.solvedV), the left contact's first where it
 //      moved, else from level contacts, a cold start.
@@ -190,6 +193,7 @@ export class SteadySolves {
     this.steady = true; // (the steady system's rows; sources at the present time)
     this.steadyAt = this.time; // (which a pseudo-transient's steps don't move on)
     this.drifted = null; // (an amount no row keeps, lost by a giant step: see _steadySteps)
+    this.modelError = null; // (a statistics model's refusal, for the failure: see newton)
     // A solve that fails leaves where the state was solved, and whether it was stepped, as they
     // were (Device.solve restores the state): a floating continuation's held solves had set them,
     // and the next held solve ramped warm from a voltage the state was never at, and failed.
@@ -252,6 +256,7 @@ export class SteadySolves {
       if (q.converged) {
         this.solvedV = [this.termV[0], this.termV[1]]; // (a contact's own: driven by a current, not the current)
         this.stepped = false;
+        this.coldStart = false; // (solved: no t = 0⁺ left for a transient to start from)
       }
       return q;
     };
@@ -289,6 +294,15 @@ export class SteadySolves {
       if (g.converged) return solved(g);
       r = g;
     }
+    // A terminal behind a resistance, cold: held at its source voltage first (with that its own
+    // continuations), then the resistance put back and solved from there (a diode behind 7 Ω·m²
+    // failed cold, and converged so; round 14's fuzzer, 4 of 9 such re-solves).
+    if (allowed && this.floating.some((k) => this.terms[k].drive.kind === 'V' && this.terms[k].drive.R > 0)) {
+      restart();
+      const q = this._resistanceContinuation(opts, r);
+      if (q.converged) return solved(q);
+      r = q;
+    }
     // A terminal driven by a current (open circuit, say): hold it at a voltage instead, march the
     // voltage until the current crosses its target, and float it from there.
     if (allowed && this.floating.some((k) => this.terms[k].drive.kind === 'I' && !this._bound(k))) {
@@ -342,9 +356,10 @@ export class SteadySolves {
   // voltage instead, whose steady solves have their own continuation, the voltage marched from
   // the start's until the current crosses its target, the crossing narrowed by bisection, and
   // the terminal floated again from beside it.
-  _floatingContinuation(opts, r) {
-    const k = this.floating.find((j) => this.terms[j].drive.kind === 'I' && !this._bound(j));
-    const drive = this.terms[k].drive, target = sourceAt(drive.src, this.time);
+  // (With `line`, terminal k behind a resistance: the current its load line passes at V,
+  // (V_src − V)/R, the target, the march from the first held terminal's level.)
+  _floatingContinuation(opts, r, k = this.floating.find((j) => this.terms[j].drive.kind === 'I' && !this._bound(j)), line = null) {
+    const drive = this.terms[k].drive, target = line ? NaN : sourceAt(drive.src, this.time), want = (V) => (line ? line(V) : target);
     // Its drive put back: redrive() finds the laws again for it, with the local constraints'
     // references at zero, so they're taken from the state again (an immobile species held at 0
     // at every node: the floated solve failed, 80 steps, and the regula falsi rescued it at 6×).
@@ -363,11 +378,12 @@ export class SteadySolves {
       iterations += q.iterations ?? 0;
       history.push({ held: V, converged: q.converged });
       if (q.converged) seen.push([V, this.termI[k]]);
-      return q.converged ? this.termI[k] - target : NaN;
+      return q.converged ? this.termI[k] - want(V) : NaN;
     };
     const fail = () => ({ converged: false, steps, iterations, history });
     const seen = []; // [V, I] of each held solve that converged
-    let Va = this.termV[k], fa, Vb, fb;
+    const heldK = this.terms.findIndex((t) => t.drive.kind === 'V' && !(t.drive.R > 0));
+    let Va = line ? (heldK >= 0 ? this.termV[heldK] : 0) : this.termV[k], fa, Vb, fb;
     try {
       fa = hold(Va);
       if (!Number.isFinite(fa)) {
@@ -396,7 +412,7 @@ export class SteadySolves {
       }
       if (!Number.isFinite(fb) || (Math.sign(fb) === Math.sign(fa) && fa !== 0)) {
         // What the held voltages passed, at the two extremes reached.
-        if (seen.length > 1) {
+        if (seen.length > 1 && !line) {
           seen.sort((a, b) => a[0] - b[0]);
           this.unreached = { terminal: this.terms[k].name, target, low: seen[0], high: seen.at(-1) };
         }
@@ -423,7 +439,7 @@ export class SteadySolves {
     // one at the voltage that passes the target: found by held solves, by regula falsi
     // (Illinois) within the bracket, to 1e-10 of the target, or at open circuit of the largest
     // current the march saw (a target of 0 is never met exactly).
-    const scale = Math.max(Math.abs(target), ...seen.map(([, I]) => Math.abs(I)));
+    const scale = Math.max(line ? 0 : Math.abs(target), ...seen.map(([, I]) => Math.abs(I)));
     try {
       let side = 0;
       for (let it = 0; it < 60; it++) {
@@ -446,6 +462,53 @@ export class SteadySolves {
     }
   }
 
+  // Each terminal behind a resistance held at its source voltage (R taken off), solved, then the
+  // resistances put back and the steady system solved from that state.
+  _resistanceContinuation(opts, r) {
+    const ks = this.floating.filter((k) => this.terms[k].drive.kind === 'V' && this.terms[k].drive.R > 0);
+    const drives = ks.map((k) => this.terms[k].drive);
+    let steps = r.steps ?? 0, iterations = r.iterations ?? 0;
+    const history = (r.history ?? []).slice();
+    // Where every other terminal is driven by a current, Kirchhoff gives the one behind R its
+    // current, and so the voltage it ends at, V_src − I R: held there, putting R back moves
+    // nothing (held at V_src, it had to slide the whole device by IR, and failed past volts).
+    const others = this.terms.every((t, j) => ks.includes(j) || t.drive.kind === 'I');
+    const at = (k) => {
+      const d = this.terms[k].drive, V = sourceAt(d.src, this.time);
+      if (!(others && ks.length === 1)) return V;
+      const I = -this.terms.reduce((t, tm, j) => (j === k ? t : t + sourceAt(tm.drive.src, this.time)), 0);
+      return V - I * d.R;
+    };
+    let heldOk = false;
+    const start = [Float64Array.from(this.u), Float64Array.from(this.uLo), Float64Array.from(this.termV)];
+    try {
+      const held = ks.map(at);
+      ks.forEach((k, j) => (this.terms[k].drive = { ...this.terms[k].drive, src: { value: held[j] }, R: 0 }));
+      this.redrive();
+      const q = this._steadyFromHere(opts);
+      steps += q.steps ?? 0;
+      iterations += q.iterations ?? 0;
+      history.push({ resistancesOff: true, converged: q.converged });
+      heldOk = q.converged;
+    } finally {
+      ks.forEach((k, j) => (this.terms[k].drive = drives[j]));
+      this.redrive();
+      captureLocal(this);
+    }
+    const q = heldOk ? this._steadySteps(opts) : { converged: false, steps: 0, iterations: 0, history: [] };
+    const done = { ...q, steps: steps + q.steps, iterations: iterations + q.iterations, history: [...history, ...q.history] };
+    if (q.converged || ks.length !== 1) return done;
+    // One terminal behind R, the rest not all driven by currents (so its current isn't known):
+    // its crossing with the load line, (V_src − V)/R, by held solves, as an open circuit's is
+    // with its target (a silver cell held at 0 V on one side, 16 V behind R on the other, failed).
+    const d = drives[0], Vs = sourceAt(d.src, this.time);
+    this.u.set(start[0]);
+    this.uLo.set(start[1]);
+    this.termV.set(start[2]);
+    this.computeConcentrations(); // (from where this stage began, not where the failed one left it)
+    return this._floatingContinuation(opts, done, ks[0], (V) => (Vs - V) / d.R);
+  }
+
   // Steady solves with the generation reactions' rates scaled from 1e-30 up to 1, ×100 a step
   // while they converge, smaller steps where they don't.
   _generationContinuation(opts, r) {

package/src/timeSteps.js

@@ -21,6 +21,8 @@
 // (ports' charges) }: what BDF2 and the predictor need.
 //
 // step(s, dt, opts) → newton's result (+ bdf)
+//   From a cold start (s.coldStart, outside a steady solve), the faces between strictly neutral
+//   regions first set to their t = 0⁺ equilibrium (equilibrateFaces, src/start.js).
 //   One step from s.time to tEnd = s.time + dt (or s.landing exactly, where it's within 1e-9·dt
 //   of that). Backward Euler; BDF2 when opts.method is 'bdf2', a previous step exists and the
 //   ratio ω = dt/dt_prev ≤ 2: then c* = b1·c_n − b2·c_{n−1} (b1 = (1+ω)/a0, b2 = ω²/((1+ω)a0),
@@ -85,6 +87,7 @@
 
 import { nextBreakpoint } from './device.js';
 import { SolverError } from './solver.js';
+import { equilibrateFaces } from './start.js';
 
 // Lagrange weights at x through the points s0, s1, s2.
 function lagrange3(x, s0, s1, s2) {
@@ -120,6 +123,8 @@ export function advance(s, dt, opts, depth = 0) {
  * the start-of-step values, and dt/a0 replaces dt.
  */
 export function step(s, dt, opts = {}) {
+  // A transient's first step from a cold start begins at its t = 0⁺ (see equilibrateFaces).
+  if (s.coldStart && !s.steady) equilibrateFaces(s);
   // What the step overwrites before Newton runs, for a failed one to put back: the Solution read
   // after it takes its contacts' fluxes against the start-of-step values (a host emptied by its
   // current read its contact's Li⁺ flux 8× off at the same state).
@@ -262,6 +267,7 @@ export function integrate(s, tEnd, opts = {}) {
   const sample = s._probes(opts.probes);
   const trace = { t: [], current: [], voltage: [], ...(sample ? { probes: sample.out } : {}) };
   let steps = 0, rejected = 0, iterations = 0, failed = false;
+  s.modelError = null; // (a statistics model's refusal, for the failure: see newton)
   // 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. A time already passed, or reached again outside
   // an animation, is most likely advance(dt) read as a duration: say so.
@@ -269,7 +275,7 @@ export function integrate(s, tEnd, opts = {}) {
     const relative = tEnd < s.time || (s.time > 0 && opts.budgetMs === undefined);
     return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace, ...(relative ? { stopped: `advance(${tEnd}) did nothing: ${absolute}. To run for a further dt, advance(sol.time + dt)` } : {}) };
   }
-  const t0 = s.time;
+  const t0 = s.time, fromLayout = s.history.length === 0 && !s.stepped && !s.atSteady; // (c0's layout, not a solution)
   // A cold start whose floating double layers start uncharged far from the equilibrium of an ion
   // link beside them (a capacitive contact or port passing K⁺, its outside level set for the
   // charged steady state): the link closes the gap in the first instant, which can be far below
@@ -395,6 +401,12 @@ export function integrate(s, tEnd, opts = {}) {
     stopped = `${at}: the start can't be neutral in ${unbalanced.join(', ')}, strictly neutral (ε = 0): the amounts its c0 gives leave a net charge that no species held at a contact's level can balance, and a step can't move a stored amount at once. Give c0 that balances (with any fixed charge), or leave out of c0 the species a contact feeds, so that they start at its level.`;
   else if (failed && violent.length > 0)
     stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. The start is violent: ${violent.join('; ')}. A double layer starts uncharged, and what passes beside it closes such a gap in the first instant, faster than any step can follow. For a start in equilibrium, solve() first (the steady state at the starting drives), then change what the experiment changes, then advance(). Where solve() fails from there too, hold that terminal at a voltage, solve(), then let it float (set its I: 0): it keeps the state the held one gave it.`;
+  else if (failed && s.modelError)
+    stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s, the state it reached refused by a statistics model: ${s.modelError}. The model doesn't hold there: a smaller concentration or drive, or a model for it (lattice for crowding).`;
+  else if (failed && fromLayout && steps === 0)
+    // (round 15's fuzzer: the pn template advanced from its c0, a step of 3e-24 s failing, 23 of 62
+    // plain diodes; nothing said to solve first)
+    stopped = `${at}: the first step did not converge even when shortened to ${dt.toExponential(1)} s, from the starting state, which is c0's layout rather than a solution (a junction's depletion not yet formed, say). For a transient from equilibrium, solve() first at the starting drives, then change what the experiment changes, then advance().`;
   else 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 (s.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: s.time >= tEnd, steps, rejected, iterations, trace, ...(stopped ? { stopped } : {}) };

package/types/impedance.d.ts

@@ -4,8 +4,8 @@ export class SmallSignal {
      * gives (J + iωM)·δx + Σ B_k δV_k = rhs for the grid's rows, and (C_k + iωC′_k)·δx +
      * (∂I_k/∂V_k)·δV_k = δI_set,k for each floating terminal's circuit row, with J the steady
      * Jacobian and M the storage part (from J(dt) = J + M/dt), B_k = ∂res/∂V_k and C_k = ∂I_k/∂x.
-     * At the measured terminal, a held voltage is perturbed (rhs = −B δV) and its current read
-     * from C, or a driven current is perturbed and its voltage solved for. The other terminals
+     * At the measured terminal, its voltage is perturbed (rhs = −B δV) and its current read, held
+     * or driven by a current alike (one input impedance; see the contract). The other terminals
      * keep their drives: held ones at AC ground, driven ones at AC open circuit.
      * Z = δV/δI with I into the device (positive real part for a passive device).
      * @param {ArrayLike<number>} frequencies Hz

package/types/solver.d.ts

@@ -273,6 +273,7 @@ export class Solver {
     };
     _warmFrom(src: any): void;
     solvedV: any;
+    coldStart: any;
     _snapshot(): {
         u: Float64Array<ArrayBuffer>;
         uLo: Float64Array<ArrayBuffer>;
@@ -299,6 +300,7 @@ export class Solver {
         history: any[];
         termV: Float64Array<ArrayBuffer>;
         sourceTime: number;
+        coldStart: any;
     };
     _restore(s: any): void;
     contactDEnd: any;

package/types/start.d.ts

@@ -4,3 +4,11 @@
  * profile varies), or continued across the interface dipole if nothing there responds.
  */
 export function initFromComposition(s: any): void;
+/**
+ * The t = 0⁺ state at the faces between strictly neutral regions, taken by the first time step
+ * from a cold start (src/timeSteps.js) and not by a steady solve, which needs no t = 0⁺: there it
+ * was the worse start, its face nodes moved while the rest of a region stayed (a stack whose
+ * middle region started 2.2 V from its neighbour's level failed every steady solve, where the
+ * cold start converged in one).
+ */
+export function equilibrateFaces(s: any): void;

package/types/steady.d.ts

@@ -29,6 +29,7 @@ export class SteadySolves {
     steady: boolean;
     steadyAt: any;
     drifted: any;
+    modelError: any;
     _solveSteadyAll(opts: any): any;
     atSteady: any;
     _steadyFromHere(opts: any): any;
@@ -36,9 +37,11 @@ export class SteadySolves {
     sourceTime: any;
     solvedV: any[];
     stepped: boolean;
+    coldStart: boolean;
     dimmer: boolean;
     _bound(k: any): any;
-    _floatingContinuation(opts: any, r: any): any;
+    _floatingContinuation(opts: any, r: any, k?: any, line?: any): any;
+    _resistanceContinuation(opts: any, r: any): any;
     _generationContinuation(opts: any, r: any): {
         converged: boolean;
         steps: any;