driftlet 0.10.0 → 0.11.4

package/src/solver.js

@@ -7,6 +7,62 @@ function bvFactor(a, alpha) {
   return { g, gp: alpha * Math.exp(alpha * a) + (1 - alpha) * e };
 }
 
+// GMRES(m), restarted, for a real system op(x) = b, op already preconditioned; x holds the
+// starting guess and receives the answer. Returns whether it converged.
+function gmresReal(op, b, x, { m = 10, restarts = 3, tol = 1e-12 } = {}) {
+  const N = b.length;
+  const dot = (a, c) => {
+    let t = 0;
+    for (let j = 0; j < N; j++) t += a[j] * c[j];
+    return t;
+  };
+  const bn = Math.sqrt(dot(b, b)) || 1;
+  for (let cycle = 0; cycle < restarts; cycle++) {
+    const ax = op(x), r = Float64Array.from(b, (v, j) => v - ax[j]);
+    const beta = Math.sqrt(dot(r, r));
+    if (!(beta > tol * bn)) return true;
+    const V = [r.map((v) => v / beta)], H = Array.from({ length: m + 1 }, () => new Float64Array(m));
+    const cs = [], sn = [], g = new Float64Array(m + 1);
+    g[0] = beta;
+    let k = 0, converged = false;
+    for (; k < m; k++) {
+      const w = op(V[k]);
+      for (let i = 0; i <= k; i++) {
+        const h = dot(V[i], w);
+        H[i][k] = h;
+        for (let j = 0; j < N; j++) w[j] -= h * V[i][j];
+      }
+      const hn = Math.sqrt(dot(w, w));
+      V.push(w.map((v) => v / (hn || 1)));
+      for (let i = 0; i < k; i++) {
+        const a = H[i][k], c = H[i + 1][k];
+        H[i][k] = cs[i] * a + sn[i] * c;
+        H[i + 1][k] = -sn[i] * a + cs[i] * c;
+      }
+      const t = Math.hypot(H[k][k], hn), c = t > 0 ? H[k][k] / t : 1, sv = t > 0 ? hn / t : 0;
+      cs.push(c);
+      sn.push(sv);
+      H[k][k] = t;
+      g[k + 1] = -sv * g[k];
+      g[k] *= c;
+      if (!(Math.abs(g[k + 1]) > tol * bn) || !(hn > 0)) {
+        k++;
+        converged = true;
+        break;
+      }
+    }
+    const y = new Float64Array(k);
+    for (let i = k - 1; i >= 0; i--) {
+      let v = g[i];
+      for (let j = i + 1; j < k; j++) v -= H[i][j] * y[j];
+      y[i] = v / H[i][i];
+    }
+    for (let i = 0; i < k; i++) for (let j = 0; j < N; j++) x[j] += y[i] * V[i][j];
+    if (converged) return true;
+  }
+  return false;
+}
+
 // Solve the K×K complex system (Ar + i Ai) x = (last column), partial pivoting by modulus.
 function complexSolve(Ar, Ai, K) {
   for (let col = 0; col < K; col++) {
@@ -39,8 +95,13 @@ function complexSolve(Ar, Ai, K) {
 }
 
 // GMRES(m), restarted, for a complex system op(x) = b, with vectors as [re, im] pairs and op
-// already preconditioned; x holds the starting guess and receives the answer.
-function gmres(op, b, x, { m = 12, restarts = 4, tol = 1e-8 } = {}) {
+// already preconditioned; x holds the starting guess and receives the answer. A cycle's own
+// residual estimate can drift far from the true one (a preconditioner nearly singular at low
+// frequency, or an op whose round-off the preconditioner amplifies), so each cycle is judged by
+// the true residual, at the next one's start: it returns once that's below tol, and gives up when
+// two cycles in a row fail to lower it, leaving x at the best iterate. Returns the true residuals (relative
+// to b) at the start and at that iterate.
+function gmres(op, b, x, { m = 12, restarts = 8, tol = 1e-8 } = {}) {
   const N = b[0].length;
   const cdot = (a, c) => {
     let re = 0, im = 0;
@@ -52,15 +113,24 @@ function gmres(op, b, x, { m = 12, restarts = 4, tol = 1e-8 } = {}) {
   };
   const norm = (a) => Math.sqrt(cdot(a, a)[0]);
   const bn = norm(b) || 1;
-  for (let cycle = 0; cycle < restarts; cycle++) {
+  const best = [Float64Array.from(x[0]), Float64Array.from(x[1])];
+  let initial = Infinity, least = Infinity, idle = 0;
+  for (let cycle = 0; ; cycle++) {
     const ax = op(x), r = [Float64Array.from(b[0], (v, j) => v - ax[0][j]), Float64Array.from(b[1], (v, j) => v - ax[1][j])];
-    const beta = norm(r);
-    if (!(beta > tol * bn)) return;
-    const V = [[r[0].map((v) => v / beta), r[1].map((v) => v / beta)]];
+    const beta = norm(r) / bn;
+    if (cycle === 0) initial = beta;
+    idle = beta < least ? 0 : idle + 1;
+    if (idle === 0) {
+      least = beta;
+      best[0].set(x[0]);
+      best[1].set(x[1]);
+    }
+    if (!(beta > tol) || cycle === restarts || idle === 2) break;
+    const V = [[r[0].map((v) => v / (beta * bn)), r[1].map((v) => v / (beta * bn))]];
     const H = Array.from({ length: m + 1 }, () => Array.from({ length: m }, () => [0, 0]));
     const cs = [], sn = [], g = Array.from({ length: m + 1 }, () => [0, 0]);
-    g[0] = [beta, 0];
-    let k = 0, converged = false;
+    g[0] = [beta * bn, 0];
+    let k = 0;
     for (; k < m; k++) {
       const w = op(V[k]);
       for (let i = 0; i <= k; i++) {
@@ -91,7 +161,6 @@ function gmres(op, b, x, { m = 12, restarts = 4, tol = 1e-8 } = {}) {
       g[k + 1] = [-(s[0] * gr + s[1] * gi), -(s[0] * gi - s[1] * gr)];
       if (!(Math.hypot(g[k + 1][0], g[k + 1][1]) > tol * bn)) {
         k++;
-        converged = true;
         break;
       }
     }
@@ -114,8 +183,10 @@ function gmres(op, b, x, { m = 12, restarts = 4, tol = 1e-8 } = {}) {
         x[1][j] += yr * V[i][1][j] + yi * V[i][0][j];
       }
     }
-    if (converged) return; // (by its own residual estimate)
   }
+  x[0].set(best[0]);
+  x[1].set(best[1]);
+  return { initial, residual: least };
 }
 
 // Discretisation and nonlinear solver.
@@ -147,6 +218,7 @@ import { BlockTridiagonal, ComplexBlockTridiagonal } from './blockTridiagonal.js
 import { bernoulli, bernoulliDerivative } from './bernoulli.js';
 import { EPS0, FARADAY } from './constants.js';
 import { nextBreakpoint, sourceAt } from './device.js';
+import { DifferenceTerms } from './difference.js';
 import { DeviceError } from './errors.js';
 import { powi, powr } from './pow.js';
 
@@ -343,6 +415,7 @@ export class Solver {
     this.time = 0;
     this.lastDt = Infinity;
     this.atSteady = false; // whether the state is a converged steady solve
+    this.lin = null; // (set while assembling for DifferenceTerms)
     // Contact bookkeeping, filled by assemble(): particle flux toward +x through each contact,
     // and the displacement there (the metal's surface charge for a neutral link).
     this.contactFlux = { left: new Float64Array(n), right: new Float64Array(n) };
@@ -415,12 +488,6 @@ export class Solver {
     );
     this.portRates = model.ports.map((port) => port.reactions.map(() => new Float64Array(port.nodes.length)));
 
-    // Whether any region is strictly neutral (ε = 0, not a conductor): see integrate().
-    this.strictlyNeutral = model.regions.some((reg) => {
-      const mat = materials[reg.material];
-      return !mat.conductor && mat.epsr === 0;
-    });
-
     // Scales the generation reactions' rates during a steady solve's continuation (else 1).
     this.generationScale = 1;
     this.hasGeneration = this.rxs.some((rx) => rx.generation);
@@ -460,6 +527,18 @@ export class Solver {
       }
     });
     this.chargeNodes = Int32Array.from([...this.chargeNode.keys()].filter((g) => this.chargeNode[g]));
+    // An end node of a strictly neutral region that its contact holds (leaving it neutral: φ law
+    // bulk or neutral): the contact's current is the ions' charge passing, and their storage
+    // carries none under neutrality, nor does the box's net charge change (a bulk law's "D").
+    // Read from the box's balance, both come with round-off ∝ c/dt that cancels only roughly,
+    // which on short steps swamps the flux (a floating bath on a dilute side rattled). So there,
+    // on a transient step, the ions' storage goes in only after the contact has read its current,
+    // and the box's charge isn't counted as displacement (see _contact).
+    this.lateStorage = new Uint8Array(nNodes);
+    [0, nNodes - 1].forEach((g, k) => {
+      const mat = materials[regions[grid.nodeRegion[g]].material], law = contacts[k === 0 ? 'left' : 'right'].phi.type;
+      if (!mat.conductor && mat.epsr === 0 && (law === 'bulk' || law === 'neutral') && !this.chargeNode[g] && !this.phiUndefined[g] && this.nodeIdeal[g]) this.lateStorage[g] = 1;
+    });
     this.combining = false;
     this.bookkeeping = regions.map((_, r) => {
       const g0 = grid.regionStart[r], g1 = grid.regionEnd[r], nodes = [], segs = [];
@@ -505,6 +584,11 @@ export class Solver {
     const sizes = new Int32Array(nB), loc = (this.loc = new Int32Array(nB * M).fill(-1));
     for (let b = 0; b < nB; b++) for (let r = 0; r < M; r++) if (active[b * M + r]) loc[b * M + r] = sizes[b]++;
     const sys = (this.sys = new BlockTridiagonal(nB, sizes));
+    // A pivot that cancels to exactly nothing (a population held only through conductances
+    // 1e-16 of its neighbours', as GaAs's minority carriers ~1 per m³ beside a face) is
+    // perturbed, not thrown on: Newton then converges, its small updates meaning small residuals
+    // (the factorisation only amplifies), refining its solves where they stall.
+    sys.staticPivots = true;
     const N = sys.size;
     this.SINK = N;
     const rix = (this.rix = new Int32Array(nB * M).fill(N)), fullOf = (this.fullOf = new Int32Array(N));
@@ -515,6 +599,7 @@ export class Solver {
     }
     this.res = new Float64Array(N + 1);
     this.delta = new Float64Array(N + 1);
+    this.rowScale = new Float64Array(N + 1).fill(1); // each row's scaling in the factorised system
   }
 
   _factor() {
@@ -564,6 +649,8 @@ export class Solver {
         if (reacting.length > 0) reactive = true;
         const connected = leftOpen || rightOpen || linked.length > 0;
         this.stretches.push({
+          leftOpen,
+          rightOpen,
           linked, // ports that hold or exchange it
           ports: [...new Set([...linked, ...reacting])], // ports that bring any in
           species: i,
@@ -594,6 +681,33 @@ export class Solver {
       st.mobile = true;
       for (let q = st.regions[0]; q <= st.regions[1]; q++) if (!(materials[regions[q].material].D[st.species] > 0)) st.mobile = false;
     }
+    // Stretches whose steady state is known outright: a species that no reaction or port touches,
+    // reached by one contact only (the other end blocked), carries no flux at steady state, so its
+    // level is flat at that contact's. Steady solves pin it there (_flatRows) rather than find it
+    // through its own conduction, which can be all but nothing: a MOS capacitor's inversion
+    // electrons reach the back contact only through a bulk with ~1e3 of them per cm³. (Not
+    // through flow or mixing, nor a concentrated material's cross-diffusion, where zero flux
+    // isn't a flat level.)
+    this.flatStretches = this.stretches.filter((st) => {
+      if (st.reactive || st.ports.length > 0 || !st.mobile || st.leftOpen === st.rightOpen) return false;
+      for (let q = st.regions[0]; q <= st.regions[1]; q++) {
+        const reg = regions[q], mat = materials[reg.material];
+        if (mat.conductor || !mat.ideal || reg.velocity !== 0 || reg.mixing > 0) return false;
+      }
+      return true;
+    });
+    // Likewise a spectator that's mobile throughout: no flux at steady state, so its level is flat,
+    // at a value its amount fixes. Steady solves hold its levels equal (_levelRows) rather than
+    // find them through its own conduction: blocked SO₄²⁻ driven from a zinc cathode's extended
+    // space charge is down to 1e-25 mol/m³ there, and the chain of conductances through it lost
+    // the steady system 14 digits. (Within one region: across a face, the rows that would hold
+    // the level and pin the face's flux leave a diagonal block singular.)
+    this.levelStretches = this.stretches.filter((st) => {
+      if (!st.spectator || !st.mobile || st.ports.length > 0 || st.regions[0] !== st.regions[1]) return false;
+      const reg = regions[st.regions[0]], mat = materials[reg.material];
+      return !mat.conductor && mat.ideal && reg.velocity === 0 && !(reg.mixing > 0);
+    });
+    this.flattening = false;
     // Conserved amounts solved directly, each in place of one (redundant) balance row: a
     // spectator's own amount, and each conserved combination of reacting stretches (the total
     // iron of Fe³⁺, Fe²⁺ and FeCl²⁺, say), whose weighted balances sum to zero at steady state.
@@ -652,6 +766,66 @@ export class Solver {
         reference: new Float64Array(sts[0].nodes[1] - sts[0].nodes[0] + 1),
       });
     }
+    // Islands: the pieces of a stretch between its faces. One that nothing else feeds (no
+    // contact, port or reaction) holds its level only through its faces' fluxes, which can be
+    // ~1e-24 of its own conduction (a tiny conductance at the face, or a neighbour that barely
+    // conducts): eliminated, the level is lost to round-off, and Newton settles at a wrong one with
+    // nothing to show for it. In steady solves the piece's balance summed over its nodes, where
+    // the internal fluxes cancel exactly and the faces' alone are left, replaces its first node's
+    // (see _applyIslands), once the plain solves converge (see newton).
+    this.islands = [];
+    this.pinnedIslands = [];
+    this.islandsOn = false; // (newton() turns them on, see there)
+    this.pins = [];
+    const used = new Set(this.constraints.map((cs) => cs.row));
+    for (const st of this.stretches) {
+      const i = st.species, [s0, s1] = st.regions;
+      if (!st.mobile || conductor(st)) continue;
+      for (let q0 = s0, q1 = s0; q1 <= s1; q1++) {
+        const p0 = q0;
+        q0 = q1 + 1;
+        if (p0 === s0 && q1 === s1) continue; // (uncut)
+        if ((p0 === s0 && st.leftOpen) || (q1 === s1 && st.rightOpen)) continue;
+        const inside = (q) => q >= p0 && q <= q1;
+        if (model.ports.some((port) => inside(port.region) && (port.species[i].type !== 'blocked' || port.reactions.some((rx) => rx.part.some((p) => p.side === 0 && p.i === i))))) continue;
+        let reactive = false;
+        for (let q = p0; q <= q1; q++) {
+          for (const rx of model.reactions) if (rx.kf[regions[q].material] > 0 && [...rx.reactants, ...rx.products].some((p) => p.i === i)) reactive = true;
+        }
+        for (let f = Math.max(0, p0 - 1); f <= Math.min(model.interfaces.length - 1, q1); f++) {
+          for (const rx of model.interfaces[f].reactions) if (rx.part.some((p) => p.i === i && inside(f + p.side))) reactive = true;
+        }
+        const row = this.blockOfNode[grid.regionStart[p0]] * this.M + 1 + i;
+        if (reactive || used.has(row)) continue;
+        used.add(row);
+        // The faces' fluxes into the piece: −A_f u at its left face, +A_f u at its right. Across
+        // a face that holds μ̄ level, u is set only by the edge balances, and eliminated, it can
+        // come out of the piece's own (G Δη, its two η all but equal: a neighbour 1e20 times
+        // less conductive, and the piece's level was seen through one face of two, and Newton
+        // swung it back and forth across both). There the outside edge node's balance is added:
+        // u cancels, and the outside's first segment carries the flux instead.
+        const faces = [], outside = [];
+        if (p0 > s0) faces.push([p0 - 1, -1, grid.regionEnd[p0 - 1]]);
+        if (q1 < s1) faces.push([q1, 1, grid.regionStart[q1 + 1]]);
+        for (const [f, , g] of faces) {
+          if (model.interfaces[f].links[i].type !== 'equilibrium' || g === 0 || g === this.nNodes - 1) continue;
+          if (model.ports.some((port) => port.nodes.includes(g))) continue;
+          outside.push(this.blockOfNode[g] * this.M + 1 + i);
+        }
+        this.islands.push({
+          stretch: st,
+          row,
+          flux: faces.map(([f]) => this.blockOfFace[f] * this.M + 1 + i),
+          weight: faces.map(([f, sg]) => sg * grid.area[grid.regionEnd[f]]),
+          outside,
+          idx: new Int32Array(faces.length + 3 * this.M * outside.length),
+          w: new Float64Array(faces.length + 3 * this.M * outside.length),
+          len: 0,
+          res: 0,
+        });
+      }
+    }
+    for (const isl of this.islands) isl.outside = isl.outside.filter((o) => !used.has(o));
     this.constrained = false;
   }
 
@@ -668,6 +842,71 @@ export class Solver {
     }
   }
 
+  // The islands' summed balances (steady solves only): Σ A_f u over the faces into each, its
+  // first node's row pinned in the factorised matrix and the sum bordered (_solveBordered) like a
+  // conserved amount's. The pieces of a stretch held flat by its contact are left as they are.
+  _applyIslands() {
+    const { u, res } = this, R = this.rix, out = [];
+    for (const isl of this.islands) {
+      if (this.flattening && this.flatStretches.includes(isl.stretch)) continue;
+      const b0 = Math.floor(isl.row / this.M), r0 = isl.row % this.M;
+      if (this.loc[isl.row] < 0) continue;
+      // Gathered by column (the faces' u, then each outside row's entries, which cancel those u
+      // exactly where they meet), then the nonzeros kept.
+      const acc = this.islandRow ?? (this.islandRow = new Float64Array(this.sys.size + 1));
+      const cols = [];
+      const add = (col, v) => {
+        if (acc[col] === 0) cols.push(col);
+        acc[col] += v;
+      };
+      let t = 0;
+      isl.flux.forEach((o, j) => {
+        if (this.loc[o] < 0) return;
+        t += isl.weight[j] * u[o];
+        add(R[o], isl.weight[j]);
+      });
+      for (const o of isl.outside) {
+        if (this.loc[o] < 0) continue;
+        t += res[R[o]];
+        this._rowInto(o, add);
+      }
+      let len = 0;
+      for (const col of cols) {
+        if (col < this.sys.size && acc[col] !== 0) {
+          isl.idx[len] = col;
+          isl.w[len++] = acc[col];
+        }
+        acc[col] = 0;
+      }
+      isl.len = len;
+      isl.res = t;
+      this._replaceRow(b0, r0);
+      for (const B of this.termB) B[R[isl.row]] = 0;
+      this._j(b0, r0, b0, r0, 1);
+      res[R[isl.row]] = 0;
+      out.push(isl);
+    }
+    return out;
+  }
+
+  // Row o's Jacobian entries, as add(compact column, value): the assembled ones, and the dilute
+  // kernels' kept aside in difference form (see _assembleDifference) when they are.
+  _rowInto(o, add) {
+    const { sys, M, nB } = this, b = Math.floor(o / M), l = this.loc[o];
+    const { A, B, C, sizes, offA, offB, offC, offX } = sys, m = sizes[b];
+    for (let k = 0; k < m; k++) if (B[offB[b] + l * m + k] !== 0) add(offX[b] + k, B[offB[b] + l * m + k]);
+    if (b > 0) for (let k = 0, mp = sizes[b - 1]; k < mp; k++) if (A[offA[b] + l * mp + k] !== 0) add(offX[b - 1] + k, A[offA[b] + l * mp + k]);
+    if (b < nB - 1) for (let k = 0, mn = sizes[b + 1]; k < mn; k++) if (C[offC[b] + l * mn + k] !== 0) add(offX[b + 1] + k, C[offC[b] + l * mn + k]);
+    if (this.lin) {
+      const into = this.linRow ?? (this.linRow = new Float64Array(sys.size + 1));
+      this.lin.capture(this.rix[o], 1, 0, into);
+      for (let k = 0; k < sys.size; k++) {
+        if (into[k] !== 0) add(k, into[k]);
+        into[k] = 0;
+      }
+    }
+  }
+
   // The local constraints' rows (steady solves only): Σ w c_i − reference at each node.
   _applyLocalConstraints() {
     const { n, M, c, res, dA: d } = this;
@@ -815,7 +1054,8 @@ export class Solver {
 
   // Solve the full Newton system, J δ = rhs, with the extra unknowns and rows that don't fit the
   // block-tridiagonal matrix T: the floating terminals' voltages (with their circuit rows), and
-  // the spectators' conservation rows (pinned in T, see _applyConstraints). By low-rank
+  // the rows pinned in T: the spectators' conserved amounts (see _applyConstraints) and the
+  // islands' summed balances (see _applyIslands). By low-rank
   // updates of T (Woodbury): δ = y + Σ_q Q_q μ_q − Σ_k X_k δV_k with y = T⁻¹ rhs, Q_q = T⁻¹ e_q
   // (the response to a unit pin) and X_k = T⁻¹ B_k (to a unit change of V_k), then a small dense
   // system for the μ (pins) and δV (terminals):
@@ -882,6 +1122,13 @@ export class Solver {
   }
 
 
+  // An electrode surface at its starting coverages at node g: η = μ°/RT + ln(θ/θ₀).
+  _surfaceStart(g) {
+    const { n, M, u, model } = this, surf = model.ports[this.surfPort[g]].surface, b = this.blockOfNode[g];
+    const bare = 1 - surf.reduce((t, sp) => t + sp.theta0, 0);
+    surf.forEach((sp, q) => (u[b * M + 1 + n + q] = sp.mu0 / model.RT + Math.log(sp.theta0 / bare)));
+  }
+
   /** Amount (mol per unit area) of surface column j's species, Γ Σ v·a·θ, in the current state. */
   surfaceAmount(j) {
     const [k, q] = this.surfCols[j], port = this.model.ports[k], vol = this.model.grid.vol;
@@ -1129,13 +1376,7 @@ export class Solver {
       const shift = level(t.side) - level(this.terms[held].side);
       if (Number.isFinite(shift)) this.termV[k] = this.termV[held] + shift;
     }
-    // Electrode surfaces at their starting coverages: η = μ°/RT + ln(θ/θ₀).
-    for (let g = 0; g < this.nNodes; g++) {
-      const k = this.surfPort[g];
-      if (k < 0) continue;
-      const surf = model.ports[k].surface, b = this.blockOfNode[g], bare = 1 - surf.reduce((t, sp) => t + sp.theta0, 0);
-      surf.forEach((sp, q) => (u[b * M + 1 + n + q] = sp.mu0 / model.RT + Math.log(sp.theta0 / bare)));
-    }
+    for (let g = 0; g < this.nNodes; g++) if (this.surfPort[g] >= 0) this._surfaceStart(g);
     this.computeConcentrations();
     // A floating capacitance starts uncharged (σ = 0 at the window's mean φ), as the starting
     // composition, neutral without it, assumes; with reactions too, its double layer then charges
@@ -1360,6 +1601,7 @@ export class Solver {
     const { grid, materials, regions } = model;
     sys.clear();
     res.fill(0);
+    if (this.lin) this.lin.reset(1 / dt);
     this.computeConcentrations();
 
     // Regions, each assembled by the kernel for its kind: a conductor (its carrier only), a
@@ -1391,8 +1633,13 @@ export class Solver {
     // Terminals: ports (after every other term at their nodes, so a held level can read its
     // flux), then contacts, then the circuit rows of the floating ones.
     this._terminals(dt);
+    if (this.flattening && dt === Infinity) this._flatRows();
+    if (this.flattening && this.constrained && dt === Infinity) this._levelRows();
     if (this.constrained && dt === Infinity && this.constraints.length > 0) this._applyConstraints();
     if (this.constrained && dt === Infinity && this.localConstraints.length > 0) this._applyLocalConstraints();
+    // Rows kept aside for _solveBordered: the conserved amounts' and the islands'.
+    this.pinnedIslands = this.constrained && dt === Infinity && this.islandsOn ? this._applyIslands() : [];
+    this.pins = this.constrained && dt === Infinity ? [...this.constraints, ...this.pinnedIslands] : [];
     this.transformed = this.combining && dt !== Infinity;
     if (this.transformed) this._chargeRows(dt);
   }
@@ -1412,7 +1659,7 @@ export class Solver {
   // charge in the Gauss row, written straight into the diagonal blocks by local index. A
   // dielectric is the case with no species.
   _nodesDilute(g0, g1, dt) {
-    const { n, M, res, c, cOld, z, sys, loc, present, rhoFixed, blockOfNode } = this, R = this.rix, F = FARADAY;
+    const { n, M, res, c, cOld, z, sys, loc, present, rhoFixed, blockOfNode, lin } = this, R = this.rix, F = FARADAY;
     const JB = sys.B, sizes = sys.sizes, offB = sys.offB, vol = this.model.grid.vol;
     for (let g = g0; g <= g1; g++) {
       const b = blockOfNode[g], v = vol[g];
@@ -1423,22 +1670,27 @@ export class Solver {
         continue;
       }
       let q = rhoFixed[g], dq = 0;
+      const late = this.combining && this.lateStorage[g] === 1 && dt !== Infinity; // (the ions' storage: in _contact)
       for (let i = 0; i < n; i++) {
         const k = g * n + i;
         if (!present[k]) continue;
-        const ck = c[k], l = loc[lb + 1 + i];
-        res[R[lb + 1 + i]] += (v * (ck - cOld[k])) / dt;
-        JB[oB + l * m + l] += (v * ck) / dt;
+        const ck = c[k], l = loc[lb + 1 + i], stores = !(late && z[i] !== 0);
+        if (stores) res[R[lb + 1 + i]] += (v * (ck - cOld[k])) / dt;
         q += F * z[i] * ck;
         dq += F * z[i] * z[i] * ck;
-        if (p >= 0 && z[i] !== 0) {
-          JB[oB + l * m + p] += (-v * z[i] * ck) / dt;
-          JB[oB + p * m + l] += -v * F * z[i] * ck;
+        if (lin) {
+          lin.node(R[lb + 1 + i], R[lb], z[i], stores ? v * ck : 0, -v * F * z[i] * ck);
+          continue;
+        }
+        if (stores) {
+          JB[oB + l * m + l] += (v * ck) / dt;
+          if (p >= 0 && z[i] !== 0) JB[oB + l * m + p] += (-v * z[i] * ck) / dt;
         }
+        if (p >= 0 && z[i] !== 0) JB[oB + p * m + l] += -v * F * z[i] * ck;
       }
       if (p >= 0) {
         res[R[lb]] -= v * q;
-        JB[oB + p * m + p] += v * dq;
+        if (!lin) JB[oB + p * m + p] += v * dq;
       }
     }
   }
@@ -1525,6 +1777,7 @@ export class Solver {
         for (let q = 0, o = offC[b] + lk * mn, s = offC[b] + li * mn; q < mn; q++) C[o + q] += w * C[s + q];
         res[rk] += w * res[ri];
         for (let t = 0; t < termB.length; t++) termB[t][rk] += w * termB[t][ri];
+        if (this.lin) this.lin.combine(rk, ri, w);
       }
       // Columns: φ̂' = φ̂ with η fixed becomes φ̂ with η_i shifted by z_i, wherever node g's
       // unknowns appear (its own rows, its neighbours', a terminal's current).
@@ -1651,6 +1904,7 @@ export class Solver {
     const mL = sys.sizes[bL], mR = sys.sizes[bR], pL = loc[bL * M], pR = loc[bR * M];
     res[R[bL * M]] += D;
     res[R[bR * M]] -= D;
+    if (this.lin) return this.lin.displacement(R[bL * M], R[bR * M], k);
     sys.B[sys.offB[bL] + pL * mL + pL] += k;
     sys.C[sys.offC[bL] + pL * mR + pR] -= k;
     sys.A[sys.offA[bR] + pR * mL + pL] -= k;
@@ -1664,7 +1918,7 @@ export class Solver {
   // fluxes (e.g. majority carriers carrying a small current) don't vanish in the cancellation of
   // two huge drift and diffusion terms.
   _segmentsDilute(g0, g1, region, mat, vel) {
-    const { n, M, u, uLo, res, c, z, sys, loc } = this, R = this.rix, F = FARADAY;
+    const { n, M, u, uLo, res, c, z, sys, loc, lin } = this, R = this.rix;
     const { A: JA, B: JB, C: JC, sizes, offA, offB, offC } = sys;
     const { segLength, segArea } = this.model.grid;
     for (let s = g0; s < g1; s++) {
@@ -1689,6 +1943,10 @@ export class Solver {
         const dNdPhiR = zi * dNdd;
         res[R[bL * M + r]] += N;
         res[R[bR * M + r]] -= N;
+        if (lin) {
+          lin.segment(R[bL * M + r], R[bR * M + r], R[bL * M], R[bR * M], zi, -gBc * E, dNdEtaR, zi * dNdd);
+          continue;
+        }
         // Row r of block bL (couplings to itself in B, to bR in C) and of bR (to bL in A).
         const lL = loc[bL * M + r], lR = loc[bR * M + r];
         const oBL = offB[bL] + lL * mL, oCL = offC[bL] + lL * mR, oAR = offA[bR] + lR * mL, oBR = offB[bR] + lR * mR;
@@ -2121,6 +2379,7 @@ export class Solver {
   _captureRow(b, s, w, into) {
     const l = this.loc[b * this.M + s];
     if (l < 0 || w === 0) return;
+    if (this.lin) this.lin.capture(this.rix[b * this.M + s], w, this.lin.rate, into);
     const { sys, nB } = this, { sizes, offA, offB, offC, offX } = sys, m = sizes[b];
     for (const [X, nb, off] of [['A', b - 1, offA], ['B', b, offB], ['C', b + 1, offC]]) {
       if (nb < 0 || nb >= nB) continue;
@@ -2323,6 +2582,19 @@ export class Solver {
         this._captureRow(b, 1 + i, z[i] * F, C);
       }
     }
+    // The ions' storage, left out until now (see lateStorage): in each balance, and in what
+    // each species brings in, but not in the current.
+    if (this.combining && dyn && this.lateStorage[g] === 1) {
+      const v = model.grid.vol[g], { cOld } = this;
+      for (let i = 0; i < n; i++) {
+        if (z[i] === 0 || this.loc[b * M + 1 + i] < 0) continue;
+        const ci = c[g * n + i], st = (v * (ci - cOld[g * n + i])) / dt;
+        res[R[b * M + 1 + i]] += st;
+        flux[i] += sgn * st;
+        this._j(b, 1 + i, b, 1 + i, (v * ci) / dt);
+        this._j(b, 1 + i, b, 0, (-v * z[i] * ci) / dt);
+      }
+    }
 
     // Conductance links: J (toward the device) = G (V_out − V_i), V_out = V_t + offset; exchange
     // links (neutral species): N_in = k (μ_out − μ)/RT.
@@ -2372,7 +2644,7 @@ export class Solver {
       // The Poisson residual is the outside's charge, D_in.
       const Din = res[R[b * M]];
       this.contactD[side] = sgn * Din;
-      if (dyn) {
+      if (dyn && !(this.combining && this.lateStorage[g] === 1)) {
         I += (Din - Dstart) / dt;
         this._captureRow(b, 0, 1 / dt, C);
       }
@@ -2405,10 +2677,59 @@ export class Solver {
 
 
 
+  // Steady solves: each flat stretch's level held at its contact's throughout (see
+  // flatStretches), in place of its balances, as an equilibrium link holds it at the end node.
+  _flatRows() {
+    const { M, u, uLo, res, z, VT, model } = this, R = this.rix;
+    for (const st of this.flatStretches) {
+      const i = st.species, side = st.leftOpen ? 'left' : 'right', k = side === 'left' ? 0 : 1;
+      const link = model.contacts[side].species[i];
+      const level = z[i] === 0 ? link.mu / model.RT : (z[i] * (this.termV[k] + link.offset)) / VT;
+      for (let g = st.nodes[0]; g <= st.nodes[1]; g++) {
+        const b = this.blockOfNode[g], o = b * M + 1 + i;
+        if (this.loc[o] < 0) continue;
+        this._replaceRow(b, 1 + i);
+        for (const B of this.termB) B[R[o]] = 0; // (the row's old terminal terms: the end node's own link)
+        this._j(b, 1 + i, b, 1 + i, 1);
+        res[R[o]] = u[o] + uLo[o] - level;
+        if (z[i] !== 0) this.termB[k][R[o]] += -z[i] / VT;
+      }
+      // A face inside the stretch whose link holds the level continuous carries the species' flux
+      // as an unknown that only the edge balances, now replaced, determined: it's zero.
+      for (let f = st.regions[0]; f < st.regions[1]; f++) {
+        if (model.interfaces[f].links[i].type !== 'equilibrium') continue;
+        const b = this.blockOfFace[f], o = b * M + 1 + i;
+        if (this.loc[o] < 0) continue;
+        this._replaceRow(b, 1 + i);
+        for (const B of this.termB) B[R[o]] = 0;
+        this._j(b, 1 + i, b, 1 + i, 1);
+        res[R[o]] = u[o] + uLo[o];
+      }
+    }
+  }
+
   // Zero one row of the Jacobian (all three blocks), ready to be replaced.
+  // Steady solves: each level stretch's levels held equal (see levelStretches), node to node in
+  // place of the balances. The first node's row is the amount's (see _applyConstraints).
+  _levelRows() {
+    const { M, u, uLo, res } = this, R = this.rix;
+    for (const st of this.levelStretches) {
+      const i = st.species;
+      for (let g = st.nodes[0] + 1; g <= st.nodes[1]; g++) {
+        const b = this.blockOfNode[g], o = b * M + 1 + i, p = o - M;
+        if (this.loc[o] < 0 || this.loc[p] < 0) continue;
+        this._replaceRow(b, 1 + i);
+        for (const B of this.termB) B[R[o]] = 0;
+        this._j(b, 1 + i, b, 1 + i, 1);
+        this._j(b, 1 + i, b - 1, 1 + i, -1);
+        res[R[o]] = u[o] + uLo[o] - (u[p] + uLo[p]);
+      }
+    }
+  }
   _replaceRow(b, rs) {
     const l = this.loc[b * this.M + rs];
     if (l < 0) return;
+    if (this.lin) this.lin.kill(this.rix[b * this.M + rs]);
     const { sys, nB } = this, sz = sys.sizes, m = sz[b];
     sys.B.fill(0, sys.offB[b] + l * m, sys.offB[b] + (l + 1) * m);
     if (b > 0) sys.A.fill(0, sys.offA[b] + l * sz[b - 1], sys.offA[b] + (l + 1) * sz[b - 1]);
@@ -2427,8 +2748,12 @@ export class Solver {
         for (let k = 0; k < mp; k++) mx = Math.max(mx, Math.abs(A[oa + k]));
         for (let k = 0; k < m; k++) mx = Math.max(mx, Math.abs(B[ob + k]));
         for (let k = 0; k < mn; k++) mx = Math.max(mx, Math.abs(C[oc + k]));
-        if (mx === 0) continue;
+        if (mx === 0) {
+          this.rowScale[offX[b] + r] = 1;
+          continue;
+        }
         const s = 1 / mx;
+        this.rowScale[offX[b] + r] = s;
         for (let k = 0; k < mp; k++) A[oa + k] *= s;
         for (let k = 0; k < m; k++) B[ob + k] *= s;
         for (let k = 0; k < mn; k++) C[oc + k] *= s;
@@ -2438,6 +2763,111 @@ export class Solver {
     }
   }
 
+  // The Jacobian at dt with the dilute kernels' terms kept aside in difference form (see
+  // DifferenceTerms), the rest assembled into a matrix of its own. The residual and terminal terms
+  // come out as from assemble(dt); the Newton matrix is left as it was.
+  _assembleDifference(dt) {
+    const keep = this.sys;
+    const rest = this.sysRest ?? (this.sysRest = new BlockTridiagonal(keep.n, keep.sizes));
+    const lin = this.diffTerms ?? (this.diffTerms = new DifferenceTerms(keep.size, this.nNodes * this.n, this.nNodes * this.n));
+    this.sys = rest;
+    this.lin = lin;
+    try {
+      this.assemble(dt);
+    } finally {
+      this.sys = keep;
+      this.lin = null;
+    }
+    return { rest, lin };
+  }
+
+  // A Newton solve refined by GMRES: the factorised Jacobian as the preconditioner, and J·x
+  // exact, with the dilute kernels' terms in difference form (see DifferenceTerms), as the
+  // impedance does. The assembled J holds a flux's dependence on η at its two ends as two
+  // entries; where they're huge (an inversion layer's 0.1 nm cells, a conductance ~1e11 against
+  // the layer's own storage and the trickle from the bulk), eliminating them loses the layer's
+  // overall level to round-off, and Newton rattles there. delta and deltaV come in as the plain
+  // solve's and leave refined (in the transformed unknowns, as _solveBordered gives them); false
+  // if refining didn't help, leaving them as they came.
+  _refine(dt, delta, deltaV) {
+    const { res, termRes, termB, termC, termDI, rowScale, floating: fl } = this;
+    const N = this.sys.size, K = fl.length, pins = this.pins, R = this.rix;
+    const save = { res: Float64Array.from(res), termRes: Float64Array.from(termRes), termB: termB.map((b) => Float64Array.from(b)), termC: termC.map((c) => Float64Array.from(c)), termDI: Float64Array.from(termDI), transformed: this.transformed, pinRes: this.pins.map((p) => p.res) };
+    const restoreArrays = () => {
+      res.set(save.res);
+      termRes.set(save.termRes);
+      save.termB.forEach((b, k) => termB[k].set(b));
+      save.termC.forEach((c, k) => termC[k].set(c));
+      termDI.set(save.termDI);
+      this.transformed = save.transformed;
+      this.pins.forEach((p, a) => (p.res = save.pinRes[a]));
+    };
+    // The same system, its terms kept apart: the rest, and each floating terminal's (unscaled).
+    const { rest, lin } = this._assembleDifference(dt);
+    const Bk = fl.map((k) => Float64Array.from(termB[k])), Ck = fl.map((k) => Float64Array.from(termC[k])), Dk = fl.map((k) => termDI[k]);
+    restoreArrays();
+    const v = new Float64Array(N + 1), jv = new Float64Array(N);
+    const op = (x) => {
+      for (let j = 0; j < N; j++) v[j] = x[j];
+      v[N] = 0;
+      rest.multiply(v, jv);
+      if (save.transformed) this._untransform(v); // (the dilute terms in the plain unknowns)
+      lin.apply(v, jv, 1, 1 / dt);
+      const out = new Float64Array(N + K);
+      for (let j = 0; j < N; j++) {
+        let t = jv[j];
+        for (let a = 0; a < K; a++) t += Bk[a][j] * x[N + a];
+        out[j] = t * rowScale[j];
+      }
+      for (let a = 0; a < K; a++) {
+        let t = Dk[a] * x[N + a];
+        for (let j = 0; j < N; j++) t += Ck[a][j] * x[j];
+        out[N + a] = t;
+      }
+      // A pinned row is its constraint's (a conserved amount, an island's summed balance).
+      for (const p of pins) {
+        let t = 0;
+        for (let j = 0; j < p.len; j++) t += p.w[j] * x[p.idx[j]];
+        out[R[p.row]] = t;
+      }
+      return precondition(out);
+    };
+    const rhs = new Float64Array(N + 1), out = new Float64Array(N + 1), outV = new Float64Array(K);
+    const precondition = (r) => {
+      for (let j = 0; j < N; j++) rhs[j] = r[j];
+      fl.forEach((k, a) => (termRes[k] = r[N + a]));
+      for (const p of pins) {
+        p.res = rhs[R[p.row]];
+        rhs[R[p.row]] = 0;
+      }
+      this._solveBordered(rhs, out, outV, pins);
+      const z = new Float64Array(N + K);
+      for (let j = 0; j < N; j++) z[j] = out[j];
+      for (let a = 0; a < K; a++) z[N + a] = outV[a];
+      return z;
+    };
+    try {
+      const b = new Float64Array(N + K);
+      for (let j = 0; j < N; j++) b[j] = save.res[j];
+      fl.forEach((k, a) => (b[N + a] = save.termRes[k]));
+      pins.forEach((p, a) => (b[R[p.row]] = save.pinRes[a]));
+      const pb = precondition(b), x = Float64Array.from(pb);
+      // A lost mode or two, GMRES finds in a couple of iterations. The refined update is kept
+      // where GMRES converged and its correction is under a thermal unit; otherwise newton()
+      // stops refining.
+      const x0 = Float64Array.from(x);
+      const ok = gmresReal(op, pb, x, { m: 8, restarts: 1, tol: 1e-8 });
+      let c = 0;
+      for (let j = 0; j < N + K; j++) c = Math.max(c, Math.abs(x[j] - x0[j]));
+      if (!ok || !(c < 1)) return false;
+      for (let j = 0; j < N; j++) delta[j] = x[j];
+      for (let a = 0; a < K; a++) deltaV[a] = x[N + a];
+      return true;
+    } finally {
+      restoreArrays();
+    }
+  }
+
   // Largest update among the potential-like unknowns (φ̂ and η at grid nodes).
   _maxPotentialStep(delta, deltaV = this.deltaV) { // (deltaV null: the device's potentials only)
     const { n, M } = this;
@@ -2460,16 +2890,55 @@ export class Solver {
    * Newton iteration for one backward-Euler step from the current cOld.
    * @returns {{converged: boolean, iterations: number, history: number[]}}
    */
-  newton(dt, { maxIter = 60, tol = 1e-10, maxStep = 10 } = {}) {
+  newton(dt, { maxIter = 60, tol = 1e-10, maxStep = 10, islands = false } = {}) {
     const { delta, res } = this;
     const deltaV = this.deltaV ?? (this.deltaV = new Float64Array(this.floating.length));
     const history = [], ownHistory = [];
-    // A steady solve that fails: record how nearly singular the system was, and where.
+    // Refined solves (see _refine), once the plain ones stall.
+    let refine = false, refined = 0, noRefine = false;
+    // Islands (see _applyIslands): their summed rows go in only once the plain solves converge.
+    // Far from the solution, Newton exact along a weakly held level takes it by 1e5 thermal
+    // units (a floating base, cold at bias), where the plain solves, which barely see that level,
+    // converge. Converged, an island at the wrong level shows: it takes in a different current
+    // than it passes on, so the terminal currents don't add up to zero. Then the summed rows go
+    // in and Newton carries on from there. Converged again, a current that tiny against the
+    // conduction around it rides on differences (~1e-28 thermal units for 5 fA/m² through a bulk
+    // of 1e4 mol/m³ at 1e-4 m²/s) that the last update leaves known only to its own round-off:
+    // where the currents still don't add up, one more update polishes them. Where the islands'
+    // own system is held by static pivots elsewhere (a GaAs stack's minority carriers, at 1e-17
+    // A/m² of noise), their rows can throw Newton off instead: if it doesn't converge again
+    // within a dozen iterations, the plain solution stands.
+    this.islandsOn = islands;
+    let rounds = 0, kept = null;
+    const islandsOff = (it, result) => {
+      if (dt !== Infinity || !this.constrained || this.islands.length === 0 || rounds >= 2 || !(this._kirchhoff() > 1e-9)) return false;
+      this.islandsOn = true;
+      rounds++;
+      kept = { it, result, u: Float64Array.from(this.u), uLo: Float64Array.from(this.uLo), termV: Float64Array.from(this.termV) };
+      return true;
+    };
+    // 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.
     const fail = (r) => {
+      if (kept) {
+        this.u.set(kept.u);
+        this.uLo.set(kept.uLo);
+        this.termV.set(kept.termV);
+        this.islandsOn = false;
+        this.computeConcentrations();
+        return { ...kept.result, iterations: r.iterations, history };
+      }
       if (dt === Infinity) this._noteConditioning();
       return r;
     };
     for (let it = 1; it <= maxIter; it++) {
+      if (kept && it - kept.it > 12) return fail({ converged: false, iterations: it - 1, history });
+      if (kept && it === kept.it + 2) {
+        // Refined from the islands' second update (their first moves the level, perhaps by
+        // more than a refinement may), since the plain solves have shown a mode they lose.
+        refine = true;
+        noRefine = false;
+      }
       try {
         this.assemble(dt);
       } catch (err) {
@@ -2486,9 +2955,13 @@ export class Solver {
         return fail({ converged: false, iterations: it, history, error: err.message });
       }
       try {
-        const pins = this.constrained && dt === Infinity ? this.constraints : [];
+        const pins = this.pins;
         deltaV.fill(0);
         this._solveBordered(res, delta, deltaV, pins);
+        if (refine && !this._refine(dt, delta, deltaV)) {
+          refine = false; // (GMRES didn't converge, or strayed: the plain solves it is)
+          noRefine = true;
+        }
         if (this.transformed) this._untransform(delta);
       } catch (err) {
         if (!(err instanceof SolverError)) throw err;
@@ -2505,7 +2978,7 @@ export class Solver {
       ownHistory.push(own);
       if (!Number.isFinite(step)) return fail({ converged: false, iterations: it, history, error: 'non-finite update' });
       // Give up early on clear divergence; the caller will take a smaller step instead.
-      if (own > 1e4 || (it > 6 && own > 10 * ownHistory[0])) {
+      if ((it > 1 && own > 1e4) || (it > 6 && own > 10 * ownHistory[0])) {
         this.computeConcentrations();
         return fail({ converged: false, iterations: it, history, error: 'diverging' });
       }
@@ -2513,8 +2986,10 @@ export class Solver {
       this._addToState(delta, -alpha);
       this.floating.forEach((k, a) => (this.termV[k] -= alpha * deltaV[a]));
       if (alpha === 1 && step < tol) {
+        const done = { converged: true, iterations: it, history, residual: rmax };
+        if (islandsOff(it, done)) continue;
         this.computeConcentrations();
-        return { converged: true, iterations: it, history, residual: rmax };
+        return done;
       }
       // Converged as far as round-off allows: the updates are already tiny (below 1e-6 thermal
       // units, ~26 nV) and have stopped shrinking. A badly conditioned system's floor can sit
@@ -2523,15 +2998,35 @@ export class Solver {
       // (Raising this floor lets a weakly held population drift: a MOS capacitor without a
       // channel port then showed a DC leak through its oxide.)
       const [p1, p2] = [history[history.length - 2], history[history.length - 3]], floor = 1e-6;
-      if (alpha === 1 && it >= 4 && step < floor && p1 < floor && step > 0.25 * p1 && p1 > 0.25 * p2) {
+      // Stalled near the solution (not shrinking quadratically), or growing undamped twice
+      // running: the factorised Jacobian may have lost a slow mode to cancellation, and
+      // round-off's floor would accept it wrong, or its noise keep Newton from the solution (a
+      // bipolar stack's floating base, its holes held ~1e14 more weakly than they move within
+      // it). Refine the solves from here.
+      if (refine) refined++;
+      else if (!noRefine && alpha === 1 && it >= 3 && step > 0.25 * p1 && (step < 1e-4 || (step > p1 && p1 > p2))) refine = true;
+      if (alpha === 1 && it >= 4 && (!refine || refined >= 1 || noRefine) && step < floor && p1 < floor && step > 0.25 * p1 && p1 > 0.25 * p2) {
+        const done = { converged: true, iterations: it, history, residual: rmax, roundoff: true };
+        if (islandsOff(it, done)) continue;
         this.computeConcentrations();
-        return { converged: true, iterations: it, history, residual: rmax, roundoff: true };
+        return done;
       }
     }
     this.computeConcentrations();
     return fail({ converged: false, iterations: maxIter, history });
   }
 
+  // How far the terminal currents (as last assembled) are from adding up to zero, relative to the
+  // largest of them: Kirchhoff's law, which a steady state keeps.
+  _kirchhoff() {
+    let sum = 0, mx = 0;
+    for (const I of this.termI) {
+      sum += I;
+      mx = Math.max(mx, Math.abs(I));
+    }
+    return mx > 0 ? Math.abs(sum) / mx : 0;
+  }
+
   // How many digits the last factorisation lost to cancellation, and where (the worst seen since
   // the steady solve began). Only for diagnosing failures: a saturated species, for instance,
   // can lose digits harmlessly.
@@ -2648,6 +3143,20 @@ export class Solver {
     let result;
     try {
       result = this.newton(dtEff, opts);
+      if (!result.converged && dtEff === Infinity && this.constrained && this.islands.length > 0) {
+        // Plain solves that don't converge may be lost along an island's level (two regions
+        // conducting 1e20 times less hold it): once more from the start, with the islands'
+        // summed rows in throughout (see newton).
+        this.u.set(this.uPrev);
+        this.uLo.set(this.uPrevLo);
+        this.termV.set(this.termVPrev);
+        if (opts.guess) {
+          this.u.set(opts.guess);
+          this.uLo.fill(0);
+        }
+        const again = this.newton(dtEff, { ...opts, islands: true });
+        result = { ...again, iterations: result.iterations + again.iterations };
+      }
     } finally {
       this.combining = false;
     }
@@ -2690,11 +3199,11 @@ export class Solver {
     if (!(tEnd > this.time)) return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace };
     let dt = this.dtNext ?? opts.dt0 ?? (tEnd - this.time) * 1e-4;
     if (!(dt > 0)) dt = (tEnd - this.time) * 1e-4;
-    let grow = 0; // longer first steps tried after a Newton failure (see below)
     // The shortest step worth trying: round-off relative to the time, or the device's fastest
     // time scale, whichever is shorter (a cold start can need steps far below a long run's 1e-14).
     const floor = Math.min(1e-14 * Math.max(tEnd, 1e-300), this.fastestTime() * 1e-2);
     const pred = new Float64Array(this.u.length), guess = new Float64Array(this.u.length);
+    const firstErrs = []; // the first step's error at each size tried (see below)
     const factor = (err, p) => (err > 0 ? Math.min(2, Math.max(0.2, 0.9 * Math.exp(Math.log(tol / err) / (p + 1)))) : 2);
     while (this.time < tEnd) {
       if (steps + rejected >= maxSteps || clock() - start > budgetMs) break;
@@ -2719,6 +3228,7 @@ export class Solver {
       this.landing = atBreak ? tb : clamped ? tEnd : undefined;
       const snap = this._snapshot();
       let err, p, half = null;
+      if (this.history.length > 0) firstErrs.length = 0;
       if (this.history.length === 0) {
         // First step: backward Euler, checked against two half steps (whose result is kept).
         const full = this.step(h);
@@ -2739,17 +3249,7 @@ export class Solver {
         if (err === undefined) {
           this._restore(snap);
           rejected++;
-          // Newton failed on the first step after a start or a jump. Usually a shorter step
-          // helps; but right after a jump in a strictly neutral (ε = 0) material, the shorter the
-          // step the worse conditioned it is (the field is fixed only through fluxes, which the
-          // storage term dwarfs), so try longer ones first.
-          if (this.strictlyNeutral && grow < 3 && h * 16 < tEnd - this.time) {
-            grow++;
-            dt = h * 16;
-          } else {
-            grow = 3;
-            dt = h / 4;
-          }
+          dt = h / 4;
           if (dt < floor) { failed = true; break; }
           continue;
         }
@@ -2767,14 +3267,20 @@ export class Solver {
         err = this._errorNorm(pred) * p.scale;
         p = p.order;
       }
-      if (err > tol) {
+      // A first step whose error doesn't shrink with it: a jump in a level held at a boundary
+      // (a bath's, after a voltage step) starts a profile self-similar in x/√t, so a first step
+      // of any length errs alike, down to the grid's own diffusion time, below Newton's reach.
+      // Three tries in a row, each within a factor 2 of the last, say so: the error is the
+      // jump's, not the step's. Take the step (backward Euler damps it as it should) and grow.
+      if (half && err > tol) firstErrs.push(err);
+      const jump = half && firstErrs.length >= 3 && firstErrs.slice(-3).every((e, j, a) => j === 0 || (e > 0.5 * a[j - 1] && e < 2 * a[j - 1]));
+      if (err > tol && !jump) {
         this._restore(snap);
         rejected++;
         dt = h * factor(err, p);
         continue;
       }
       steps++;
-      grow = 0;
       // The state the first step started from needn't satisfy the algebraic equations (φ in a
       // strictly neutral region, an interface's unknowns, after a start or a jump), and they
       // jump in the first instant; a predictor through it would see that jump as error on every
@@ -3034,52 +3540,17 @@ export class Solver {
     for (const X of ['A', 'B', 'C']) S[X] = sys[X].map((v, k) => (v - J[X][k]) * dts);
     const Cs = this.termC.map((v, k) => v.map((x, j) => (x - Ct[k][j]) * dts));
     const DIs = this.termDI.map((x, k) => (x - DI[k]) * dts);
-    // J·v + (∂res/∂V_k)σ from the residual itself, by a central difference: 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 flux to round-off; the residual takes the η
-    // difference first, in double-double. So η moves in the low word, φ̂ and the flux unknowns
-    // in the high one (φ̂ only scales expm1(Δη), near zero there).
-    const u0 = Float64Array.from(this.u), uLo0 = Float64Array.from(this.uLo), V0 = Float64Array.from(this.termV);
-    // The unknowns perturbed in the low word: a node's η (not φ̂, a metal's segment flux, or a
-    // face's unknowns, which are read from the high word).
-    const low = new Uint8Array(this.fullOf.length);
-    const nodeBlock = new Uint8Array(nB);
-    for (let g = 0; g < this.nNodes; g++) if (this.nodeConductor[g] < 0) nodeBlock[this.blockOfNode[g]] = 1;
-    for (let j = 0; j < low.length; j++) {
-      const full = this.fullOf[j];
-      low[j] = nodeBlock[Math.floor(full / M)] && full % M !== 0 ? 1 : 0;
-    }
-    const resP = new Float64Array(this.res.length), resM = new Float64Array(this.res.length);
-    const derivative = (v, k, sigma, out) => {
-      let mx = Math.abs(sigma);
-      for (let j = 0; j < v.length; j++) mx = Math.max(mx, Math.abs(v[j]));
-      const h = 1e-4 / (mx || 1);
-      for (const [sgn, into] of [[1, resP], [-1, resM]]) {
-        this.u.set(u0);
-        this.uLo.set(uLo0);
-        this.termV.set(V0);
-        for (let j = 0; j < v.length; j++) {
-          const full = this.fullOf[j];
-          if (low[j]) this.uLo[full] += sgn * h * v[j];
-          else this.u[full] += sgn * h * v[j];
-        }
-        // A held terminal's voltage comes from its source at each assembly; a floating one's is
-        // an unknown.
-        if (k >= 0 && fl.includes(k)) this.termV[k] += sgn * h * sigma;
-        else if (k >= 0) this.sourceOverride.set(k, V0[k] + sgn * h * sigma);
-        this.assemble(Infinity);
-        if (k >= 0) this.sourceOverride.delete(k);
-        into.set(this.res);
-      }
-      for (let j = 0; j < out.length; j++) out[j] = (resP[j] - resM[j]) / (2 * h);
-    };
-    const restore = () => {
-      this.u.set(u0);
-      this.uLo.set(uLo0);
-      this.termV.set(V0);
-      this._refreshSources();
-      this.computeConcentrations();
-    };
+    const cuts = this._currentCuts();
+    // 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
+    // flux to round-off. So the dilute kernels' terms are kept in difference form (see
+    // DifferenceTerms), with the rest from a matrix of their own, steady (Jr) and storage (Sr).
+    this._assembleDifference(Infinity);
+    const Jr = { A: this.sysRest.A.slice(), B: this.sysRest.B.slice(), C: this.sysRest.C.slice() };
+    const { lin } = this._assembleDifference(dts);
+    const Sr = {};
+    for (const X of ['A', 'B', 'C']) Sr[X] = this.sysRest[X].map((v, k) => (v - Jr[X][k]) * dts);
+    this.assemble(Infinity);
 
     const { sizes, offA, offB, offC, offX } = sys;
     const csys = new ComplexBlockTridiagonal(nB, sizes);
@@ -3125,9 +3596,6 @@ export class Solver {
         }
       }
       csys.factor();
-      // Each solve uses that residual-based J·v (S·v is safe from the matrix): in an inversion
-      // layer fed by minority carriers that number ~1e3 cm⁻³ in the bulk, the assembled J alone
-      // gives the layer an exchange path many orders too fast.
       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;
@@ -3153,25 +3621,35 @@ export class Solver {
         csys.solve(rRes, iRes, outR, outI);
         return [outR, outI];
       };
-      const op = ([vr, vi]) => {
-        derivative(vr, -1, 0, jr);
-        derivative(vi, -1, 0, ji);
-        sx(S, vi, si);
-        sx(S, vr, sr);
-        const ar = new Float64Array(Nc), ai = new Float64Array(Nc);
+      // (J + iωS)·v, exactly (see DifferenceTerms), into (ar, ai).
+      const jv = (vr, vi, ar, ai) => {
+        sx(Jr, vr, jr);
+        sx(Jr, vi, ji);
+        sx(Sr, vi, si);
+        sx(Sr, vr, sr);
         for (let j = 0; j < Nc; j++) {
           ar[j] = jr[j] - w * si[j];
           ai[j] = ji[j] + w * sr[j];
         }
+        lin.apply(vr, ar, 1, 0);
+        lin.apply(vi, ar, 0, -w);
+        lin.apply(vi, ai, 1, 0);
+        lin.apply(vr, ai, 0, w);
+      };
+      const op = ([vr, vi]) => {
+        const ar = new Float64Array(Nc), ai = new Float64Array(Nc);
+        jv(vr, vi, ar, ai);
         return precondition(ar, ai);
       };
       const solve = (br, bi, outr, outi, k, sigma) => {
         const rhs = k >= 0 ? precondition(Bt[k].map((v) => -sigma * v), zero) : [new Float64Array(Nc), new Float64Array(Nc)];
         outr.set(rhs[0]);
         outi.set(rhs[1]);
-        gmres(op, rhs, [outr, outi]);
-        restore();
+        // (GMRES keeps its best iterate, which is never worse than the factorised solve.)
+        const { residual } = gmres(op, rhs, [outr, outi]);
+        accuracy = Math.max(accuracy, residual);
       };
+      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++) {
@@ -3211,12 +3689,93 @@ export class Solver {
         xr[this.fullOf[j]] = re;
         xi[this.fullOf[j]] = im;
       }
+      // The current into terminal kT per volt, (C + iωC′)·δx + (∂I/∂V)(1 + iω′), with its error.
+      // At the contact it's a sum whose terms can be far larger than itself (in a junction's
+      // neutral ends, a conductance times a δη that cancels its neighbours' to 1e-17), and its
+      // round-off reads as a constant conductance. Between the two contacts of a device without
+      // ports, the total current (conduction and displacement) is the same through every cut, so
+      // it's also read across each segment, and the reading with the least error taken. Each
+      // reading's error is its terms' round-off and the solves' error in δx (to `accuracy` of its
+      // largest entry) through its coefficients: a contact's or a cut's flux is a difference of
+      // levels that the solved rows don't pin.
+      // `parts`: the response as a sum, each part compact (r, i) and full-index (fr, fi), with the
+      // absolute error of its entries.
+      const read = (parts) => {
+        const eps = 1.1e-16, c = Ct[kT], cs = Cs[kT];
+        let Ir = DI[kT], Ii = w * DIs[kT], err = eps * (Math.abs(DI[kT]) + w * Math.abs(DIs[kT]));
+        for (const p of parts) {
+          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);
+        }
+        if (!cuts || kT >= 2) return { Ir, Ii, err };
+        const sgn = kT === 0 ? 1 : -1;
+        for (const cut of cuts) {
+          let re = 0, im = 0, e = 0;
+          for (const p of parts) {
+            for (let a = 0; a < cut.idx.length; a++) {
+              const x = cut.idx[a], gk = cut.g[a], dk = w * cut.d[a];
+              // (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);
+            }
+          }
+          if (e < err) [err, Ir, Ii] = [e, sgn * re, sgn * im];
+        }
+        return { Ir, Ii, err };
+      };
+      const largest = (r, i) => {
+        let m = 0;
+        for (let j = 0; j < r.length; j++) m = Math.max(m, Math.hypot(r[j], i[j]));
+        return m;
+      };
+      const full = (r, i) => {
+        const fr = new Float64Array(N), fi = new Float64Array(N);
+        for (let j = 0; j < Nc; j++) {
+          fr[this.fullOf[j]] = r[j];
+          fi[this.fullOf[j]] = i[j];
+        }
+        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] = dot(kT, w, yr, yi);
-        Ir += DI[kT];
-        Ii += w * DIs[kT];
+        // δ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
+        // response is split: a uniform shift of each region (z_i s on every η_i, s on φ̂), which
+        // changes no flux and no concentration, so that J·e vanishes inside each region and is
+        // taken at its edges; and what's left, small, solved for to GMRES's floor, its error now
+        // relative to itself. An electrolyte at its open circuit needs it: the response to its
+        // terminal is nearly such a shift, and its current the slope of levels uniform to 1e-14,
+        // more than a double can hold. (Not with ports, whose exchange sees the shift.)
+        if (K === 0 && cuts && err > 1e-2 * Math.hypot(Ir, Ii)) {
+          const [er, ei] = this._regionShift(yr, yi);
+          const tr = new Float64Array(Nc), ti = new Float64Array(Nc);
+          jv(er, ei, tr, ti);
+          const edge = this._regionEdgeRows();
+          const ar = new Float64Array(Nc), ai = new Float64Array(Nc);
+          for (let j = 0; j < Nc; j++) {
+            ar[j] = -Bt[kT][j] - (edge[j] ? tr[j] : 0);
+            ai[j] = edge[j] ? -ti[j] : 0;
+          }
+          const rhs = precondition(ar, ai);
+          const dr = yr.map((v, j) => v - er[j]), di = yi.map((v, j) => v - ei[j]);
+          const { residual } = gmres(op, rhs, [dr, di], { tol: 1e-11 });
+          const [efr, efi] = full(er, ei), [dfr, dfi] = full(dr, di);
+          const r2 = read([
+            { r: er, i: ei, fr: efr, fi: efi, floor: 0 },
+            { r: dr, i: di, fr: dfr, fi: dfi, floor: Math.max(1e-14, residual) * largest(dr, di) },
+          ]);
+          if (r2.err < err) ({ Ir, Ii, err } = r2);
+          if (profiles) {
+            for (let j = 0; j < N; j++) {
+              xr[j] = efr[j] + dfr[j];
+              xi[j] = efi[j] + dfi[j];
+            }
+          }
+        }
         const d2 = Ir * Ir + Ii * Ii; // Z = 1/δI
         Zr = Ir / d2;
         Zi = -Ii / d2;
@@ -3233,6 +3792,125 @@ export class Solver {
     return out;
   }
 
+  // A uniform shift of each region, fitted to a small-signal response (compact, complex): φ̂ by
+  // s_r and each species' η by z_i s_r, with s_r the region's mean δφ̂ (or, where φ̂ isn't an
+  // unknown, its carriers' mean δη/z). Coverages and flux unknowns aren't shifted.
+  _regionShift(yr, yi) {
+    const { n, M, z, loc, model } = this, R = this.rix, { grid } = model;
+    const er = new Float64Array(yr.length), ei = new Float64Array(yr.length);
+    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];
+      for (let g = g0; g <= g1; g++) {
+        const o = this.blockOfNode[g] * M;
+        if (loc[o] >= 0) {
+          sr += yr[R[o]];
+          si += yi[R[o]];
+          k++;
+        }
+      }
+      if (k === 0) {
+        for (let g = g0; g <= g1; g++) {
+          const o = this.blockOfNode[g] * M;
+          for (let i = 0; i < n; i++) {
+            if (z[i] === 0 || loc[o + 1 + i] < 0) continue;
+            sr += yr[R[o + 1 + i]] / z[i];
+            si += yi[R[o + 1 + i]] / z[i];
+            k++;
+          }
+        }
+      }
+      if (k === 0) continue;
+      sr /= k;
+      si /= k;
+      for (let g = g0; g <= g1; g++) {
+        const o = this.blockOfNode[g] * M;
+        if (loc[o] >= 0) {
+          er[R[o]] = sr;
+          ei[R[o]] = si;
+        }
+        for (let i = 0; i < n; i++) {
+          if (loc[o + 1 + i] < 0) continue;
+          er[R[o + 1 + i]] = z[i] * sr;
+          ei[R[o + 1 + i]] = z[i] * si;
+        }
+      }
+    }
+    return [er, ei];
+  }
+
+  // Compact rows a region's uniform shift can touch: faces, the nodes beside them, and the two
+  // ends (whatever holds a level from outside). Inside a region, every row is unchanged by it.
+  _regionEdgeRows() {
+    const { M, loc, nB } = this, R = this.rix;
+    const edge = new Uint8Array(this.sys.size);
+    const mark = (b) => {
+      if (b < 0 || b >= nB) return;
+      for (let r = 0; r < M; r++) if (loc[b * M + r] >= 0) edge[R[b * M + r]] = 1;
+    };
+    mark(0);
+    mark(nB - 1);
+    for (let f = 0; f < this.nFaces; f++) {
+      const b = this.blockOfFace[f];
+      mark(b - 1);
+      mark(b);
+      mark(b + 1);
+    }
+    return edge;
+  }
+
+  // The cuts where the impedance may read a small-signal current (null where the current
+  // differs between cuts: a device with ports). Each is the linearised total current toward +x
+  // through one segment of an ideal region, Σ (g + iω d)·δu over the unknowns idx: the
+  // Scharfetter–Gummel fluxes' derivatives (as in _segmentsDilute) and the displacement's.
+  _currentCuts() {
+    const { model, n, M, u, uLo, c, z } = this, F = FARADAY;
+    if (model.ports.length > 0) return null;
+    const { grid, materials, regions } = model;
+    const cuts = [];
+    for (let r = 0; r < regions.length; r++) {
+      const reg = regions[r], mat = materials[reg.material];
+      if (mat.conductor || !mat.ideal || reg.mixing > 0) continue;
+      const vel = reg.velocity;
+      for (let s = grid.regionStart[r]; s < grid.regionEnd[r]; s++) {
+        const bL = s + r, bR = bL + 1, h = grid.segLength[s] / grid.segArea[s];
+        const terms = new Map();
+        const add = (x, g, d) => {
+          const t = terms.get(x) || [0, 0];
+          t[0] += g;
+          t[1] += d;
+          terms.set(x, t);
+        };
+        const phiL = u[bL * M], phiR = u[bR * M], hasPhi = !this.phiUndefined[s];
+        for (let i = 0; i < n; i++) {
+          if (z[i] === 0 || !mat.present[i] || mat.D[i] === 0) continue;
+          const zi = z[i], r1 = 1 + i, cL = c[s * n + i], g = mat.D[i] / h;
+          const pe = (vel * h) / mat.D[i];
+          const d = zi * (phiR - phiL) - pe;
+          const E = Math.expm1(u[bR * M + r1] - u[bL * M + r1] + (uLo[bR * M + r1] - uLo[bL * M + r1]) - pe);
+          const gBc = g * bernoulli(d) * cL;
+          const dNdd = -g * bernoulliDerivative(d) * cL * E;
+          add(bL * M + r1, zi * F * gBc, 0);
+          add(bR * M + r1, -zi * F * gBc * (E + 1), 0);
+          if (hasPhi) {
+            add(bL * M, zi * F * (-zi * dNdd + zi * gBc * E), 0);
+            add(bR * M, zi * F * zi * dNdd, 0);
+          }
+        }
+        // The displacement toward +x, ε(φ_L − φ_R)/h (in φ̂ = φ/V_T).
+        const k = hasPhi ? (mat.epsr * EPS0 * this.VT) / h : 0;
+        if (k > 0) {
+          add(bL * M, 0, k);
+          add(bR * M, 0, -k);
+        }
+        if (terms.size === 0) continue;
+        const idx = [...terms.keys()];
+        cuts.push({ idx, g: idx.map((x) => terms.get(x)[0]), d: idx.map((x) => terms.get(x)[1]) });
+      }
+    }
+    return cuts;
+  }
+
   // Complex profiles of δφ (V), δμ̄ (J/mol) and δc (mol/m³) from a small-signal solution.
   _smallSignalProfiles(xr, xi) {
     const { n, M, z, VT, model } = this;
@@ -3362,6 +4040,16 @@ export class Solver {
   // Steady state from the present one; `atSteady` says whether the state is one (until a step or
   // a change of drive).
   solveSteady(opts = {}) {
+    this.flattening = true;
+    this.unreached = null; // (a driven current no held voltage reaches: see _floatingContinuation)
+    try {
+      return this._solveSteadyAll(opts);
+    } finally {
+      this.flattening = false;
+    }
+  }
+
+  _solveSteadyAll(opts) {
     // A terminal that passes current only by charging (a gate, a capacitance with no species
     // through it) has no steady state under a current drive: it charges for ever, or at I = 0
     // keeps whatever charge it started with, which a steady solve doesn't know.
@@ -3399,25 +4087,44 @@ export class Solver {
     if (r.converged) return r;
     // Generation (e.g. light) holding the device far from equilibrium: ramp it up from nearly
     // nothing, each solve warm from the last.
+    let dimmer = false;
     if (this.hasGeneration && opts.continuation !== false) {
       this.u.set(u0);
       this.uLo.set(u0Lo);
       this.termV.set(v0);
       this.computeConcentrations();
+      this.dimmer = false;
       const g = this._generationContinuation(opts, r);
+      dimmer = this.dimmer;
       if (g.converged) {
         this.solvedV = target;
         return g;
       }
       r = g;
     }
+    // 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 (opts.continuation !== false && this.floating.some((k) => this.terms[k].drive.kind === 'I')) {
+      this.u.set(u0);
+      this.uLo.set(u0Lo);
+      this.termV.set(v0);
+      this.computeConcentrations();
+      const q = this._floatingContinuation(opts, r);
+      if (q.converged) return q;
+      r = q;
+    }
     if (!canContinue) {
       if (quick) {
-        this.u.set(u0);
-        this.uLo.set(u0Lo);
-        this.termV.set(v0);
+        // The full pseudo-transient ramp: from the dimmer light's solution where the light's
+        // continuation got anywhere (a lit floating base charges from there as it would in
+        // time), else from the start.
+        if (!dimmer) {
+          this.u.set(u0);
+          this.uLo.set(u0Lo);
+          this.termV.set(v0);
+        }
         this.computeConcentrations();
-        const full = this._solveSteady(opts); // the full pseudo-transient ramp
+        const full = this._solveSteady(opts);
         return { ...full, steps: full.steps + r.steps, iterations: full.iterations + r.iterations };
       }
       return r;
@@ -3445,18 +4152,121 @@ export class Solver {
     return { ...r, steps: r.steps + c.steps, iterations: r.iterations + c.iterations };
   }
 
+  // A cold steady solve with a terminal driven by a current, which can fail where the same state
+  // is easy warm (a solar cell's open circuit, from cold on a fine grid): the terminal held at a
+  // 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');
+    const drive = this.terms[k].drive, target = sourceAt(drive.src, this.time);
+    let steps = r.steps ?? 0, iterations = r.iterations ?? 0;
+    const history = (r.history ?? []).slice();
+    const hold = (V) => {
+      this.terms[k].drive = { kind: 'V', src: { value: V }, R: 0 };
+      this.redrive();
+      const q = this._steadyFromHere(opts);
+      steps += q.steps ?? 0;
+      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;
+    };
+    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;
+    try {
+      fa = hold(Va);
+      if (!Number.isFinite(fa)) {
+        Va = 0;
+        fa = hold(Va);
+      }
+      if (!Number.isFinite(fa)) return fail();
+      // March, the step growing: up where the current is below its target, since raising a
+      // terminal's voltage raises the current into a passive device (the other way, from the
+      // start again, if 20 V brings no crossing).
+      const start = Va, f0 = fa;
+      [Vb, fb] = [Va, fa];
+      for (const dir of [fa < 0 ? 1 : -1, fa < 0 ? -1 : 1]) {
+        [Va, fa] = [start, f0];
+        if (dir !== (f0 < 0 ? 1 : -1)) hold(start); // (back to the start, for a warm march)
+        let dV = 0.02;
+        Vb = Va + dir * dV;
+        fb = hold(Vb);
+        while (Number.isFinite(fb) && Math.sign(fb) === Math.sign(fa) && fa !== 0 && Math.abs(Vb - start) < 20) {
+          [Va, fa] = [Vb, fb];
+          dV *= 1.5;
+          Vb = Va + dir * dV;
+          fb = hold(Vb);
+        }
+        if (Number.isFinite(fb) && (Math.sign(fb) !== Math.sign(fa) || fa === 0)) break;
+      }
+      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) {
+          seen.sort((a, b) => a[0] - b[0]);
+          this.unreached = { terminal: this.terms[k].name, target, low: seen[0], high: seen.at(-1) };
+        }
+        return fail();
+      }
+      // Bisect (each held solve warm from the last) to a tenth of a millivolt.
+      for (let it = 0; it < 40 && Math.abs(Vb - Va) > 1e-4; it++) {
+        const Vm = (Va + Vb) / 2, fm = hold(Vm);
+        if (!Number.isFinite(fm)) return fail();
+        if (Math.sign(fm) === Math.sign(fa)) [Va, fa] = [Vm, fm];
+        else [Vb, fb] = [Vm, fm];
+      }
+      hold(Math.abs(fa) < Math.abs(fb) ? Va : Vb);
+    } finally {
+      this.terms[k].drive = drive;
+      this.redrive();
+    }
+    const q = this._solveSteady(opts);
+    steps += q.steps ?? 0;
+    iterations += q.iterations ?? 0;
+    history.push(...(q.history ?? []));
+    if (q.converged) return { ...q, steps, iterations, history };
+    // Floated, the system can lose what held it doesn't (a closed redox cell driven near its
+    // limit: its bordered row 33 digits short), but a current-driven steady state is the held
+    // 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.
+    try {
+      let side = 0;
+      for (let it = 0; it < 60; it++) {
+        const Vm = Va - (fa * (Vb - Va)) / (fb - fa), fm = hold(Vm);
+        if (!Number.isFinite(fm)) return fail();
+        if (Math.abs(fm) <= 1e-10 * Math.abs(target)) return { converged: true, steps, iterations, history, residual: Math.abs(fm) };
+        if (Math.sign(fm) === Math.sign(fb)) {
+          [Vb, fb] = [Vm, fm];
+          if (side === -1) fa /= 2;
+          side = -1;
+        } else {
+          [Va, fa] = [Vm, fm];
+          if (side === 1) fb /= 2;
+          side = 1;
+        }
+      }
+      return fail();
+    } finally {
+      this.terms[k].drive = drive;
+      this.redrive();
+    }
+  }
+
   // Steady solves with the generation reactions' rates scaled from 1e-12 up to 1, ×100 a step
   // while they converge, smaller steps where they don't.
   _generationContinuation(opts, r) {
     const sub = this._directSteady() ? { ...opts, maxSteps: 1 } : opts;
-    let s = 1e-12, factor = 100, steps = r.steps, iterations = r.iterations;
+    let s = 1e-30, factor = 100, steps = r.steps, iterations = r.iterations;
     const history = r.history.slice();
     try {
       this.generationScale = s;
+      // (nearly dark: a cold start can need the full ramp, as a dark device's does)
       let q = this._solveSteady(sub);
       steps += q.steps;
       iterations += q.iterations;
       if (!q.converged) return { converged: false, steps, iterations, history };
+      this.dimmer = true; // (the state is now a solution under dimmer light: a better start than cold)
       while (s < 1) {
         const next = Math.min(1, s * factor);
         const u1 = Float64Array.from(this.u), u1Lo = Float64Array.from(this.uLo), v1 = Float64Array.from(this.termV);
@@ -3474,7 +4284,7 @@ export class Solver {
           this.termV.set(v1);
           this.computeConcentrations();
           factor = Math.sqrt(factor);
-          if (factor < 1.01) return { converged: false, steps, iterations, history };
+          if (factor < 1.5) return { converged: false, steps, iterations, history }; // (crawling: time steps do better)
         }
       }
       return { converged: true, steps, iterations, history };
@@ -3492,6 +4302,17 @@ export class Solver {
       let q;
       if (!warm) {
         q = this._solveSteady(opts);
+        if (!q.converged) {
+          // A cold device's start was laid out for the target (a set() before the first solve
+          // builds it there): lay it out again, level.
+          steps += q.steps;
+          iterations += q.iterations;
+          this._refreshSources();
+          this.initFromComposition();
+          q = this._solveSteady(opts);
+        }
+        // (lit, the level start may need the light ramped up too)
+        if (!q.converged && this.hasGeneration) q = this._generationContinuation(opts, q);
         steps += q.steps;
         iterations += q.iterations;
         if (!q.converged) return { ...r, steps, iterations };
@@ -3540,7 +4361,8 @@ export class Solver {
     const direct = this._directSteady();
     const giant = direct ? Infinity : 1e6 * tau;
     if (direct) this._renormalizeSpectators(); // a starting point with the right amounts
-    let dt = giant;
+    let dt = giant, grow = 10; // (after a failure, dt grows by less, then back up to ×10)
+    let triedDirect = 0;
     let totalIter = 0, steps = 0, converged = false;
     const history = [];
     while (steps < maxSteps) {
@@ -3561,6 +4383,7 @@ export class Solver {
         // Pseudo-transient continuation: down from a slow time scale until a step converges,
         // as far as the fastest (slow ions mustn't stop it short of what a cold start needs).
         dt = dt >= giant ? tau * 1e-6 : dt / 4;
+        grow = 2;
         if (dt < Math.min(tau * 1e-15, this.fastestTime() * 1e-2)) break;
         continue;
       }
@@ -3568,6 +4391,21 @@ export class Solver {
         converged = true; // the steady equations themselves were solved
         break;
       }
+      // Past the slowest diffusion time, the direct solve may already reach from here: try it
+      // once a decade (the state kept if it fails), rather than step on to the giant dt through
+      // steps that can fail for slow ions' sake.
+      if (direct && dt < giant && dt >= tau && dt >= 10 * triedDirect) {
+        triedDirect = dt;
+        const snap = this._snapshot();
+        const d = this.step(Infinity);
+        totalIter += d.iterations;
+        history.push({ dt: Infinity, converged: d.converged, iterations: d.iterations });
+        if (d.converged) {
+          converged = true;
+          break;
+        }
+        this._restore(snap);
+      }
       if (dt >= giant && this._maxPotentialStep(this._diff()) < tol) {
         converged = true;
         if (dt > giant) {
@@ -3580,7 +4418,8 @@ export class Solver {
         break;
       }
       if (dt < giant) {
-        dt *= 10; // ramping up after a failure
+        dt *= grow; // ramping up after a failure
+        grow = Math.min(10, grow * 1.5);
         if (dt > 1e6 * tau) dt = giant; // then the direct steady solve (or the giant step)
       } else if (dt < 1e6 * giant) {
         dt *= 10; // conserved amounts present and still moving: let dt keep growing (capped)