driftlet 1.3.2 → 1.3.3

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

@@ -541,7 +541,12 @@ levels are that material's, and the end node takes them through a Donnan step.
 - `'pinned'` with `zeroCharge`: the $`C \to \infty`$ limit,
   $`\phi_{\mathrm{edge}} = V - \mathtt{zeroCharge}`$. This is what a "fixed $`\phi`$" boundary honestly
   means. For example, a Schottky barrier $`\phi_B`$ on n-type material with
-  $`\mu^\circ_{\mathrm{e}^-} = 0`$ is `zeroCharge: φ_B`.
+  $`\mu^\circ_{\mathrm{e}^-} = 0`$ is `zeroCharge: φ_B`. With a carrier linked in equilibrium, a
+  pinned contact sets that carrier's density at the edge,
+  $`c_{\mathrm{edge}} = c_{\mathrm{ref}} \exp\big((z F\,\mathtt{zeroCharge} - \mu^\circ)/RT\big)`$, so a contact that injects holes at
+  $`N_v`$ (their `cRef`, $`\mu^\circ = 0`$) is `zeroCharge: 0`, and a 0.5 eV barrier for them is
+  `zeroCharge: -0.5`. This is the contact for a layer of one carrier with nothing to neutralise it
+  (a hole-only organic diode): `ohmic()`'s `'bulk'` law, local neutrality, can't hold there.
 
 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

package/docs/kit.md

@@ -59,8 +59,9 @@ console.log(`I = ${sol.current.toFixed(1)} A/m²`);
   infinite-recombination contact; `['e-']` alone is selective, and is the current collector on
   a metal region). `bath(c, reference, drive, { offset, material })` is a bath whose terminal voltage is
   the level of its `reference` species, as an electrode reversible to it would read (`offset`
-  places that species relative to the terminal voltage, e.g. to read a solution's potentials
-  against SHE). `bath(c, drive)`, without a reference, is a bath whose terminal voltage is its
+  places that species relative to the terminal voltage, its level at V + `offset`, e.g. to read a
+  solution's potentials against SHE). Every species a bath lists is held at its level there, so
+  one absent from the bulk (a product) is given as a trace, not 0. `bath(c, drive)`, without a reference, is a bath whose terminal voltage is its
   φ: an ideal salt bridge, the convention of membrane potentials, so that between two such baths
   V_right − V_left is the φ difference a voltage clamp sets. A drive is a voltage, a waveform, or
   `{ V }`, `{ I }`, `{ V, R }`. A bath against a charged layer (an ion exchanger) gives its own
@@ -448,7 +449,10 @@ page can show that its numbers hold up. Pass the solution `solve()` or `advance(
   term named by its equation; two with the same equation (radiative and SRH recombination, both
   `e- + h+ = 0`) are told apart by their place, `e- + h+ = 0 (bulkReactions[1])`, and
   `sol.bulkReactions[k]` has each one's rates. A species at rest
-  (in equilibrium, flows only of round-off against what it could carry) isn't listed.
+  (in equilibrium, flows only of round-off against what it could carry) isn't listed. Where none
+  is left, it says "equilibrium" only if no flow comes within ε of what it could carry; otherwise
+  it names the largest, which may be round-off or a real flow too small to check this way (a
+  reverse diode's 1 µA/m², 4e-15 of what its holes could carry).
 - **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

package/docs/numerics.md

@@ -951,6 +951,17 @@ A solve that fails falls back stage by stage:
      the floated solve fails, held solves find that voltage instead, by regula falsi within the
      bracket, to 1e-10 of the current. (Not a terminal at no current that keeps an amount or a
      charge: every voltage passes nothing there.)
+   - **A resistance.** A terminal behind a resistance R, its source at $`V_{\mathrm{src}}`$, is
+     found the same way, held at voltages marched from the held terminal's level until the
+     device's current crosses the load line's, $`(V_{\mathrm{src}} - V)/R`$, and floated from
+     beside it. Held at its source instead and the resistance put back, the state would sit
+     $`IR`$ from the answer, and the pseudo-transient relaxes that over $`RC`$ at the pace Newton
+     takes through the swing: a lit Schottky diode passing 0.9 A/m² took 0.05 s behind
+     1 Ω·m² and 105 s behind 10⁵ Ω·m² that way, and takes 33 ms behind any R by the load line
+     (80 fuzzed diodes from 0.01 to 10⁷ Ω·m²: 1835 s → 34 s). That route remains for terminals the load line doesn't
+     fit: several behind resistances, or one beside terminals all driven by currents, where
+     Kirchhoff gives its current and it's held at $`V_{\mathrm{src}} - IR`$ (from there, putting
+     $`R`$ back moves nothing).
    - **The voltages.** The right terminal's voltage ramped to its target: from the contacts'
      voltages at the last converged solve when the state is that solution (the left one first,
      where it moved), and otherwise from level terminals, where a cold start is consistent. (A

package/docs/statistics.md

@@ -105,7 +105,11 @@ $`\ln\gamma_i = -z_i^2 \ell_B \kappa / (2(1 + \kappa a))`$, with the Bjerrum len
 $`\ell_B = e^2/(4\pi\varepsilon kT)`$ and $`\kappa^2 = F^2 \sum z^2 c / (\varepsilon RT)`$ from the
 solvent permittivity `epsr` (which defaults to the material's, if that's non-zero) and a
 distance of closest approach `a` (default 0, the limiting law). It stops being convex at high
-ionic strength, and the solver then reports a failure.
+ionic strength, and the solver then reports a failure. It goes on a material's `statistics`, as
+any model does; with `aqueous()`, on the piece it returns: `lib.materials.water.statistics =
+[{ type: 'debye-huckel', species: ['H+', 'Cl-'], a: 4.5e-10 }]`. `a` is an ion size (a few
+ångström: tabulated per ion, as Kielland's sizes, or fitted to measured γ±), and it matters:
+in 10 mM HCl, 4.5 Å against the limiting law moves a concentration cell's voltage by 0.6 mV.
 
 Single-ion activity coefficients are a convention: only neutral combinations (the mean
 activity $`\gamma_\pm`$) are measurable. In a strictly neutral ($`\varepsilon = 0`$) material only

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.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';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/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.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';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/plot.js';
 
 const def = build({
   T: 300,
@@ -558,7 +558,8 @@ species }` (its flux) or `{ interface: f, gate }`.
   (docs/statistics.md). At no current (`I: 0`), `solve()` keeps the charge it holds: a closed
   battery sits at the OCV of its state of charge, a floating gate keeps its charge.
 - **Other steps.** `dev.step(dt)` is one backward-Euler step, and `dev.impedance(frequencies,
-  { terminal })` the small-signal Z(f) about the steady state, in Ω·m².
+  { terminal })` the small-signal Z(f) about the steady state, in Ω·m²: `{ f, Z: { re, im } }`,
+  each an array over the frequencies (`Z.re[k]`, not `Z[k].re`).
 
 ```js
 import { Device, units, FARADAY } from 'driftlet';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "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/checks.js

@@ -181,6 +181,12 @@ function balance(device, sol) {
   // 1e-19 of its scale, to 1e-15), and round-off doesn't. (Above 1e-8 of the scale, any.)
   const balanced = (l) => Math.abs(l.terms.reduce((a, t) => a + t.rate, 0)) <= 1e-9 * size(l);
   const moving = ledgers.filter((l) => size(l) > 1e-8 * scale(l) || (size(l) > 1e-20 * scale(l) && balanced(l)));
+  // What's left unbalanced can be round-off or a small real flow the solve didn't settle (a
+  // reverse diode behind a resistance, 1.3 µA/m² at 4e-15 of its scale, balanced to 8e-5 by a
+  // solve that stalled), and nothing here tells them apart: round-off reaches 8e-12 of the scale
+  // in the stress devices, and one in a thousand of those flows balances to 1%. So above ε of the
+  // scale it isn't called equilibrium: the largest is named, as what balance can't check.
+  const unsure = ledgers.filter((l) => !moving.includes(l) && size(l) > 1e-16 * scale(l)).sort((a, b) => size(b) / scale(b) - size(a) / scale(a))[0];
   let worst = 0;
   const lines = [];
   for (const l of moving) {
@@ -195,7 +201,9 @@ function balance(device, sol) {
   const ok = worst < 1e-6;
   const summary =
     moving.length === 0
-      ? 'nothing flows or reacts (equilibrium)'
+      ? unsure
+        ? `nothing flows that it can tell from round-off: the largest, ${unsure.title} at ${sig(size(unsure))} ${units.rate}${unsure.z !== 0 ? ` (${sig(FARADAY * Math.abs(unsure.z) * size(unsure))} ${units.current})` : ''}, is ${sig(size(unsure) / scale(unsure), 1)} of what it could carry and doesn't balance (to ${sig(Math.abs(unsure.terms.reduce((a, t) => a + t.rate, 0)) / size(unsure), 1)}), so it's round-off, or a flow too small for this check`
+        : 'nothing flows or reacts (equilibrium)'
       : `${moving.length === 1 ? 'one ledger sums' : `${moving.length} ledgers sum`} to zero ${ok ? `(to ${sig(worst, 1)})` : `only to ${sig(worst, 2)}: not a steady state`}: each species' sources and sinks, ${units.rate}, + in or made`;
   // The largest current any charged species carries anywhere: the scale a net current is read against.
   const gross = Math.max(0, ...moving.filter((l) => l.z !== 0).map((l) => FARADAY * Math.abs(l.z) * size(l)));

package/src/device.js

@@ -811,6 +811,7 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
       need(speciesIndex.has(sname), `${path}.bath.c.${sname}: unknown species '${sname}'${known(speciesIndex)}`);
       const i = speciesIndex.get(sname);
       need(mat.present[i], `${path}.bath.c.${sname}: '${sname}' is absent from ${reg.name} (material '${mat.name}'), so its level outside means nothing here`);
+      need(v !== 0, `${path}.bath.c.${sname}: a bath holds each species it lists at its level, and at 0 there is none (ln 0); a species absent from the bulk (a product, say) is a trace there, 1e-6 of the rest or so, so that it can leave`);
       cb[i] = positive(v, `${path}.bath.c.${sname}`);
     }
     const zb = bathZeta(mat, cb, reg.background);
@@ -1359,6 +1360,7 @@ function normalizeContact(cdef, side, region, materials, species, speciesIndex,
       need(speciesIndex.has(sname), `${path}.bath.c.${sname}: unknown species '${sname}'${known(speciesIndex)}`);
       const i = speciesIndex.get(sname);
       need(bm.present[i], `${path}.bath.c.${sname}: '${sname}' is absent from ${own ? 'the bath' : 'the end'} material '${bm.name}'`);
+      need(v !== 0, `${path}.bath.c.${sname}: a bath holds each species it lists at its level, and at 0 there is none (ln 0); a species absent from the bulk (a product, say) is a trace there, 1e-6 of the rest or so, so that it can leave`);
       cb[i] = positive(v, `${path}.bath.c.${sname}`);
       charge += species[i].z * cb[i];
       scale += Math.abs(species[i].z) * cb[i];
@@ -1413,6 +1415,20 @@ function normalizeContact(cdef, side, region, materials, species, speciesIndex,
       links.some((l, i) => l.type !== 'blocked' && species[i].z !== 0),
       `${path}.phi: 'bulk' needs at least one connected charged species at this contact`,
     );
+    // Neutral at the contact must be possible: an undoped layer of holes alone never is, and
+    // ohmic(V, ['h+']) on one failed with "nothing specific showed why" (round 16's cold agent).
+    if (!mat.conductor && !mat.phiFree && !mat.models.some((md) => md.type === 'insertion')) {
+      const signs = new Set(species.flatMap((sp, i) => (mat.present[i] && sp.z !== 0 ? [Math.sign(sp.z)] : [])));
+      const fixed = Math.sign(region.fixedCharge ?? 0);
+      if (signs.size === 1 && !(fixed !== 0 && !signs.has(fixed))) {
+        const [only] = signs;
+        throw new DeviceError(
+          `${path}.phi: 'bulk' (what ohmic() and a bath use) holds the contact neutral, but '${region.name ?? region.material}' can't be: ` +
+            `its only charged species are ${only > 0 ? 'positive' : 'negative'} and no fixed charge balances them (an undoped layer of one carrier). ` +
+            "For a contact that sets the carrier's density, pin φ instead: phi: 'pinned' with zeroCharge, the contact's level against the carrier's (see docs/device.md, contacts).",
+        );
+      }
+    }
   }
 
   if (terminal !== null) {

package/src/kit.js

@@ -50,10 +50,14 @@ export function vacuumLevel(def, side, path = 'vacuum') {
   if (!Number.isFinite(side.offset)) fail(`${path}.offset must be a finite number (V)`);
   if (side.anchor === 'phi') return -side.offset;
   const sp = (def.species ?? []).find((s) => s.name === side.anchor);
-  if (!sp) fail(`${path}.anchor must be 'phi' or a charged species, got ${JSON.stringify(side.anchor)}`);
+  if (!sp)
+    fail(
+      `${path}.anchor must be 'phi' or a charged species of the device, got ${JSON.stringify(side.anchor)}` +
+        (typeof side.anchor === 'string' ? ` (to anchor on it, list it in the library: aqueous([..., '${side.anchor}']), say)` : ''),
+    );
   if (!(sp.z !== 0)) fail(`${path}.anchor: '${side.anchor}' is neutral, so it has no level in volts`);
   const entry = mat.species?.[side.anchor];
-  if (!isObject(entry)) fail(`${path}.anchor: '${side.anchor}' is absent from '${side.material}'`);
+  if (!isObject(entry)) fail(`${path}.anchor: '${side.anchor}' is absent from '${side.material}' (to anchor on it, give the material that species)`);
   if (!Number.isFinite(entry.mu0)) fail(`${path}.anchor: '${side.anchor}' in '${side.material}' has no mu0`);
   return entry.mu0 / (sp.z * FARADAY) - side.offset;
 }

package/src/solution.js

@@ -272,10 +272,16 @@ export function makeSolution(solver, result = {}) {
         'advance() in time instead, or give the still species a small D where it is still.',
     );
   } else if (slow.length > 0) {
+    // Too slow to wait out only where the solve waited: where no time step was taken at all, the
+    // start was the trouble (a hole-only layer full of the anode's holes, with traps: "raise its
+    // rate constant" changed nothing, ×1e4).
+    const waited = (result.history ?? []).some((h) => h.converged && h.dt > 0);
     for (const { where, affinity } of slow) {
       sol.warnings.push(
         `the solve did not converge, likely because ${where} is out of equilibrium by ${(affinity * solver.VT * 1e3).toPrecision(3)} mV of affinity, yet nothing else makes or uses what it changes, so a steady state needs it at equilibrium: ` +
-          'it is too slow for the steady solve to wait out. Raise its rate constant (the steady state does not depend on it), or advance() in time.',
+          (waited
+            ? 'it is too slow for the steady solve to wait out. Raise its rate constant (the steady state does not depend on it), or advance() in time.'
+            : 'the solve failed from its first steps, so start it nearer that equilibrium: c0 near it, or solve without the reaction and set() it back.'),
       );
     }
   } else if (result.converged === false && cond && cond.digits > 12) {

package/src/start.js

@@ -29,9 +29,11 @@
 //      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 (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
+//      neutrality is out of reach (c0's amounts leave a charge no held level balances): in a
+//      strictly neutral region the running φ̂, the region noted in s.unbalanced (for a transient
+//      that fails from it to say why); otherwise the φ̂ nearest the running one, toward less
+//      charge, where the charge is at most ε V_T/(F L²) (L the region's length: what it holds with
+//      a thermal voltage across it), or where it stops falling (a fixed charge). 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).
@@ -63,7 +65,8 @@
 //      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
+//      charge = 0) to the bisection's tolerance, unless neutrality is out of reach (step 1: then
+//      its charge at most ε V_T/(F L²), or the least φ̂ gives, to the bisection's tolerance); a
 //      strictly neutral region given by amounts is neutral by its c0, checked.
 //   4. Steps 2 and 3 change no concentration but as they say: step 3 is a gauge (φ̂ and each η by
 //      z·Δ), step 2 moves the passing species between a face's two nodes only.
@@ -81,7 +84,7 @@
 // Tests: every test (each device starts here); test/transient.test.js on what a start must be.
 
 import { gateRate } from './boundaries.js';
-import { FARADAY } from './constants.js';
+import { EPS0, FARADAY } from './constants.js';
 import { sourceAt } from './device.js';
 import { profileAt, SolverError } from './solver.js';
 
@@ -260,13 +263,39 @@ export function initFromComposition(s) {
       while (charge(lo) < 0 && lo > -1e4) lo -= 2 * (hi - lo);
       while (charge(hi) > 0 && hi < 1e4) hi += 2 * (hi - lo);
       // Out of reach (every responding carrier has one sign and nothing balances it, as in an
-      // undoped layer that holds only holes): keep the running φ̂ rather than run it to ±∞.
+      // undoped layer that holds only holes): not run to ±∞, but where the charge is no more than
+      // the region holds with a thermal voltage across it, ε V_T/(F L²), or as little as it gets
+      // (a fixed charge left). Kept at the running φ̂ (a contact's level), a hole-only layer 100
+      // nm thick started full of the anode's 1e27 m⁻³ holes, 7 kV of space charge: with traps in
+      // it, every step failed from there.
       if (charge(lo) < 0 || charge(hi) > 0) {
         // In a strictly neutral region that's a start that can't be: the amounts c0 gives leave
         // a charge no level-held species can balance. Noted, for a transient that fails from it
         // to say so (a steady solve, its levels from the contacts, can still find the state).
-        if (mat.epsr === 0) s.unbalanced.push(r);
-        return ph;
+        if (mat.epsr === 0) {
+          s.unbalanced.push(r);
+          return ph;
+        }
+        const L = grid.x[grid.regionEnd[r]] - grid.x[grid.regionStart[r]];
+        const most = (mat.epsr * EPS0 * model.RT) / (FARADAY * FARADAY * L * L);
+        const q0 = charge(ph), dir = q0 > 0 ? 1 : -1; // (the charge falls as φ̂ rises)
+        if (!(Math.abs(q0) > most)) return ph;
+        let a = ph, qa = Math.abs(q0);
+        for (let step = 1; step < 1e4; step *= 2) {
+          let b = a + dir * step;
+          const qb = Math.abs(charge(b));
+          if (qb <= most) {
+            for (let it = 0; it < 100 && Math.abs(b - a) > 1e-9; it++) {
+              const m = 0.5 * (a + b);
+              if (Math.abs(charge(m)) > most) a = m;
+              else b = m;
+            }
+            return b;
+          }
+          if (!(qb < qa * (1 - 1e-9))) return a; // (a fixed charge: as little as it gets)
+          [a, qa] = [b, qb];
+        }
+        return a;
       }
       for (let it = 0; it < 200 && hi - lo > 1e-12; it++) {
         const m = 0.5 * (lo + hi);

package/src/steady.js

@@ -49,11 +49,14 @@
 //      (this.stepped), on a direct device with continuation not off, the same again from a cold
 //      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
-//      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
+//   2. Continuation: generation ramped up (_generationContinuation); terminals behind a
+//      resistance (_resistanceContinuation): one whose current Kirchhoff doesn't give, held at
+//      voltages marched to its load line's crossing (_floatingContinuation with a line); else, or
+//      where that fails, each held (at its source voltage, 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 (and where that fails for one terminal held by
+//      Kirchhoff, its load line); 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.
@@ -462,8 +465,10 @@ 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.
+  // One terminal behind a resistance: its load line's crossing by held solves. Otherwise (or where
+  // that fails), each terminal behind a resistance held at its source voltage (R taken off; at
+  // V_src − I R where Kirchhoff gives I), 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);
@@ -479,8 +484,29 @@ export class SteadySolves {
       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)];
+    const restore = () => {
+      this.u.set(start[0]);
+      this.uLo.set(start[1]);
+      this.termV.set(start[2]);
+      this.computeConcentrations();
+    };
+    // 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, first. Held at its source instead, the state is I R from the answer and
+    // the pseudo-transient relaxes it over R C at Newton's pace through that swing (a lit Schottky
+    // diode passing 0.9 A/m²: 0.05 s at 1 Ω·m², 10 s at 1e4, 105 s at 1e5, steps ∝ R).
+    const d = drives[0], Vs = sourceAt(d.src, this.time), line = (V) => (Vs - V) / d.R;
+    const byLine = ks.length === 1 && !others;
+    if (byLine) {
+      const q = this._floatingContinuation(opts, r, ks[0], line);
+      if (q.converged) return q;
+      restore(); // (from where this stage began, not where the failed one left it)
+      steps = q.steps ?? steps;
+      iterations = q.iterations ?? iterations;
+      history.splice(0, history.length, ...(q.history ?? []));
+    }
+    let heldOk = false;
     try {
       const held = ks.map(at);
       ks.forEach((k, j) => (this.terms[k].drive = { ...this.terms[k].drive, src: { value: held[j] }, R: 0 }));
@@ -497,16 +523,10 @@ export class SteadySolves {
     }
     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);
+    if (q.converged || ks.length !== 1 || byLine) return done;
+    // Where Kirchhoff's hold failed too, the load line.
+    restore();
+    return this._floatingContinuation(opts, done, ks[0], line);
   }
 
   // Steady solves with the generation reactions' rates scaled from 1e-30 up to 1, ×100 a step