driftlet 0.14.0 → 0.16.4

package/src/solver.js

@@ -478,6 +478,7 @@ export class Solver {
     model.ports.forEach((port, k) => port.capacitance && port.nodes.forEach((g, w) => this.qgTerms[g].push([2 + k, w])));
     this.contactDOld = { left: 0, right: 0 };
     this.contactDStart = { left: 0, right: 0 };
+    this.lawForm = new Map(); // (each circuit law: read as its change this step, see _circuitLaws)
     // Terminals (the two contacts, then the ports): each one's voltage (V), held by its source or
     // floating (driven by a current, or behind a resistance), and its current into the device.
     // Sources are read at sourceTime: a step's end, or now for a steady solve.
@@ -490,6 +491,9 @@ export class Solver {
     this.steady = false; // inside a steady solve: sources at the present time, not a step's end
     // The floating ones are extra unknowns, solved with the grid's by bordering (_solveBordered).
     this.floating = this.terms.flatMap((t, k) => (t.drive.kind === 'I' || t.drive.R > 0 ? [k] : []));
+    this.drivenKey = this._drivenKey();
+    this.lawRefs = new Map(); // what a steady solve keeps behind a terminal at no current (_captureLaws)
+    this.chargeRefs = new Map(); // …and the charge a terminal at no current that only charges keeps
     // Per terminal: B = ∂res/∂V (compact column), C = ∂I/∂x (compact row), ∂I/∂V, and for a
     // floating one its circuit residual (I − I_set, or I − (V_src − V)/R).
     this.termB = this.terms.map(() => new Float64Array(this.sys.size + 1));
@@ -725,49 +729,125 @@ 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;
+    // Stretches that carry nothing in a steady state, so whose level is flat there: a species that
+    // no reaction or port touches, reached by one contact at most, moving through ideal regions
+    // without flow or mixing (where carrying nothing is a level flat). Found through their own
+    // conduction, which can be all but nothing, such a level can't be moved (a MOS capacitor's
+    // inversion electrons, which reach the back contact only through a bulk with ~1e3 of them per
+    // cm³; blocked SO₄²⁻ driven from a zinc cathode's extended space charge, down to 1e-25 mol/m³
+    // there, whose chain of conductances lost the system 14 digits). So steady solves hold it
+    // flat (_flatRows): at its contact's level, or reaching none, at the level its amount fixes.
+    // (Not through flow or mixing, nor a concentrated material's cross-diffusion, where carrying
+    // nothing isn't a level flat.)
+    const plain = (st) => {
+      if (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;
+    };
+    this.flatStretches = this.stretches.filter((st) => !st.reactive && plain(st));
+    // Likewise a group of stretches that react only among themselves, each reaching the same one
+    // contact and nothing else, their reactions balanced at that contact's levels (no light, no
+    // other reservoir): in a steady state, one reservoir drives nothing, so the group is at
+    // equilibrium, each level flat at the contact's. A MOS capacitor's electrons and the holes
+    // they recombine with reach only its back contact: moved, slow generation through a bulk of
+    // GaAs with ~1e-4 electrons per cm³ couldn't carry the inversion layer's level with it.
+    const group = this.stretches.map((_, k) => k), root = (k) => (group[k] === k ? k : (group[k] = root(group[k])));
+    const join = (ks) => ks.forEach((k) => (group[root(k)] = root(ks[0])));
+    const rxns = []; // [stretches, A/RT at the contact's levels, as a function of the side]
+    regions.forEach((reg, q) => {
+      for (const rx of this.rxsIn[reg.material]) {
+        const ks = rx.sp.map((i) => this.stretchOf[q * n + i]);
+        join(ks);
+        rxns.push([ks, (side) => rx.sp.reduce((a, i, p) => a + rx.nu[p] * this.contactEta(side, i), rx.fixedA)]);
+      }
+    });
+    model.interfaces.forEach((itf, f) => {
+      for (const rx of itf.reactions) {
+        const ks = rx.part.map((p) => this.stretchOf[(f + p.side) * n + p.i]);
+        if (ks.some((k) => k < 0)) continue;
+        join(ks);
+        rxns.push([ks, (side) => rx.part.reduce((a, p) => a + p.nu * this.contactEta(side, p.i), rx.fixedA)]);
+      }
     });
-    // 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);
+    const groups = new Map();
+    this.stretches.forEach((st, k) => {
+      if (!st.reactive) return;
+      if (!groups.has(root(k))) groups.set(root(k), []);
+      groups.get(root(k)).push(k);
     });
-    this.flattening = false;
+    for (const ks of groups.values()) {
+      const sts = ks.map((k) => this.stretches[k]), side = sts[0].leftOpen ? 'left' : 'right';
+      if (!sts.every((st) => plain(st) && st.leftOpen !== st.rightOpen && (side === 'left' ? st.leftOpen : st.rightOpen))) continue;
+      if (!rxns.every(([rk, A]) => !rk.some((k) => ks.includes(k)) || Math.abs(A(side)) < 1e-9)) continue;
+      this.flatStretches.push(...sts);
+    }
+    this._laws();
+  }
+
+  // Whether a stretch's species moves through it (mobile in every region, or a metal's carrier),
+  // or stays still in every region (D = 0: trap states, conserved node by node).
+  _moves(st) {
+    const { regions, materials } = this.model;
+    for (let q = st.regions[0]; q <= st.regions[1]; q++) {
+      const mat = materials[regions[q].material];
+      if (!(mat.conductor || mat.D[st.species] > 0)) return false;
+    }
+    return true;
+  }
+
+  _still(st) {
+    const { regions, materials } = this.model;
+    for (let q = st.regions[0]; q <= st.regions[1]; q++) {
+      const mat = materials[regions[q].material];
+      if (mat.conductor || mat.D[st.species] > 0) return false;
+    }
+    return true;
+  }
+
+  // Whether terminal k (a contact, or port k − 2) feeds stretch st: links its species there.
+  _feeds(k, st) {
+    return k === 0 ? st.leftOpen : k === 1 ? st.rightOpen : st.linked.includes(k - 2);
+  }
+
+  // What a steady solve keeps (under the terminals' present drives, so again after a change of
+  // drive): each conserved amount, solved directly in place of one (redundant) balance row, and
+  // the islands' summed balances.
+  _laws() {
+    const { model } = this, { regions, materials, grid } = model;
+    const laws = this._conservedMoieties(true);
+    for (const st of this.stretches) st.conserved = 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.
-    // Immobile stretches conserve node by node instead, and a floating conductor holds charge on
-    // its faces; both are left to giant time steps.
+    // spectator's own amount (a floating metal's: the charge on its faces), each conserved
+    // combination of reacting stretches (the total iron of Fe³⁺, Fe²⁺ and FeCl²⁺, say), whose
+    // weighted balances sum to zero at steady state, and what a terminal driven at no current
+    // keeps behind it. A combination may take in still stretches (the electrons trap states hold),
+    // their amounts summed like any other; one of still stretches alone conserves node by node
+    // instead (below), and one of a stretch still in part only is left to giant time steps.
     this.constraints = [];
     const conductor = (st) => materials[regions[st.regions[0]].material].conductor;
-    const add = (parts, rowStretch, surface = []) => {
+    // The terminals driven by a current that feed a stretch: a combination through one keeps what
+    // the state holds when a solve begins (see _captureLaws), and has no steady state at any other
+    // current.
+    const driven = (st) => this.terms.flatMap((t, k) => (t.drive.kind === 'I' && this._feeds(k, st) ? [k] : []));
+    const add = (parts, rowStretch, surface = [], circuit = -1, carriers = []) => {
       const st = this.stretches[rowStretch];
       let nNodes = parts.reduce((m, p) => m + this.stretches[p.stretch].nodes[1] - this.stretches[p.stretch].nodes[0] + 1, 0);
       for (const p of surface) nNodes += model.ports[this.surfCols[p.col][0]].nodes.length * model.ports[this.surfCols[p.col][0]].surface.length;
+      for (const p of carriers) nNodes += model.ports[p.k - 2].nodes.length;
       for (const p of parts) this.stretches[p.stretch].conserved = true;
       this.constraints.push({
         parts,
         surface,
-        row: this.blockOfNode[st.nodes[0]] * this.M + 1 + st.species,
+        carriers, // (what a port's electrode holds, Q/(zF) at weight w: see _conservedMoieties)
+        terminals: [...new Set([...parts.flatMap((p) => driven(this.stretches[p.stretch])), ...carriers.map((p) => p.k)])],
+        key: parts.map((p) => `${p.stretch}:${p.w}`).join() + surface.map((p) => `|${p.col}:${p.w}`).join() + carriers.map((p) => `|T${p.k}:${p.w}`).join(),
+        circuit, // (the terminal whose circuit row it stands in for, or −1 for a balance row's, `row`)
+        // (and the terminal's weight in it, w/z on what that feeds: the amount changes by λ I/F)
+        lambda: circuit < 0 ? 0 : (carriers.find((p) => p.k === circuit)?.w / this.z[model.ports[circuit - 2]?.terminal] || parts.map((p) => (driven(this.stretches[p.stretch]).includes(circuit) ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0)),
+        row: circuit >= 0 ? -1 : this.blockOfNode[st.nodes[0]] * this.M + 1 + st.species,
         idx: new Int32Array(nNodes * this.M),
         w: new Float64Array(nNodes * this.M),
         len: 0,
@@ -776,38 +856,151 @@ export class Solver {
       });
     };
     this.stretches.forEach((st, k) => {
-      if (st.spectator && st.mobile) add([{ stretch: k, w: 1 }], k);
+      if (!st.spectator || !this._moves(st)) return;
+      add([{ stretch: k, w: 1 }], k);
+      // Held flat (see _flatRows), it moves as a whole: the pin's response is the whole stretch's
+      // shift, its amount saying how far.
+      if (this.flatStretches.includes(st)) this.constraints.at(-1).col = Array.from({ length: st.nodes[1] - st.nodes[0] + 1 }, (_, j) => this.blockOfNode[st.nodes[0] + j] * this.M + 1 + st.species);
     });
-    const S = this.stretches.length;
-    for (const w of this.moieties) {
+    const S = this.stretches.length, T = this.terms.length, X = S + this.surfCols.length;
+    const zc = (k) => this.z[model.ports[k - 2].terminal];
+    // The rows replaced: a moving stretch's balance (one of still stretches alone is kept node by
+    // node, below), or the circuit row of a terminal driven at no current, which says nothing the
+    // combination's balance rows don't (their weighted sum is that terminal's current, weighted
+    // by w/z). Together they must be independent, each combination's weights over the rows
+    // replaced a nonsingular matrix, or one balance is lost and another said twice (A + B = AB and
+    // A + C = AC: −A + B + C in place of B's row, B + AB of AB's and A − B + AC of A's said B and
+    // A twice and C not at all, and the solve converged to a state that wasn't steady). So they're
+    // chosen by elimination, each combination's weights reduced by the rows already chosen: a
+    // circuit row where one is left, else the first stretch with weight 1, else the basis
+    // vector's own (its weight is 1 there, and no other vector's is), else the largest.
+    const rowOf = (k) => this.blockOfNode[this.stretches[k].nodes[0]] * this.M + 1 + this.stretches[k].species;
+    const chosen = []; // (a column and the reduced weights, per row replaced: S + t for terminal t's)
+    const spectators = new Set(this.constraints.map((cs) => cs.row));
+    // What an electrode holds goes only in its terminal's circuit row (its charge depends on the
+    // terminal's voltage, which a balance row's pin can't carry): the combinations through it come
+    // first, so that the first takes that row, and the rest have its multiple taken off.
+    const through = (w) => this.carriers.some((k, j) => w[X + j] !== 0);
+    const held = new Map(); // (terminal → the combination in place of its circuit row)
+    // Reactions' equilibria first. A face reaction that alone changes some combination (without
+    // it, w would be conserved: Ag⁺ closed in a cell where Ag⁺ + e⁻ = Ag(s) is its one source, or
+    // Ag⁺ + AgNO₃ where it also complexes) has that combination's summed balance rows equal to its
+    // rate, w·ν times it, which a steady state sets to zero. The rate is a poor row: k₀ times a
+    // function of the levels, beside diffusion's terms in the same balances. An Ag⁺/Ag couple
+    // 1e-20 as fast as Fe³⁺/Fe²⁺ on the same platinum was lost to their round-off, the
+    // open-circuit potential settling where silver wasn't (−0.4661 V, the joint equilibrium
+    // −0.5004 V), and 1e-15 to 1e-18 failed. Its affinity says the same at any k₀ (each kinetic
+    // form vanishes only there), so it stands in for one of those rows (see _applyAffinities),
+    // chosen by the same elimination, and a stretch's: never a circuit row.
+    // The slowest first, whose rate rows are the poorest, and each row picked by the reaction's
+    // own terms, never by where its species are listed: the same rows in any listing. (Picked by
+    // listing, an electrode's two couples took different rows with the species reversed, and
+    // Newton converged in one listing and crawled in the other.)
+    this.affinities = [];
+    const faceRx = model.interfaces.flatMap((itf, f) => itf.reactions.map((rx) => ({ f, rx, key: rx.part.map((p) => `${model.species[p.i].name}:${p.side}:${p.nu}`).sort().join() })));
+    faceRx.sort((a, b) => a.rx.k0 - b.rx.k0 || (a.key < b.key ? -1 : a.key > b.key ? 1 : a.f - b.f));
+    for (const { f, rx } of faceRx) {
+      const nu = new Float64Array(S);
+      let inFlat = false;
+      for (const p of rx.part) {
+        const k = this.stretchOf[(f + p.side) * this.n + p.i];
+        if (k < 0 || this.flatStretches.includes(this.stretches[k])) inFlat = true;
+        else nu[k] += p.nu;
+      }
+      if (inFlat) continue; // (held flat at a contact's levels, in equilibrium already)
+      // (Not one fed by a terminal driven by a current: its sum is the rate plus what that
+      // passes. Silver's, e⁻ + Fe²⁺ with the electrons fed, or Ag⁺ + AgNO₃, which nothing is.
+      // A current held at zero passes nothing: an electrode at open circuit feeding a closed
+      // pool of Ag⁺ beside a slow Fe³⁺/Fe²⁺ couple settled 78 mV off, its iron not stationary.)
+      const passes = (k) => !this._noCurrent(this.terms[k]);
+      const fed = (w) => w.some((x, k) => x !== 0 && ((k >= X && passes(this.carriers[k - X])) || (k < S && driven(this.stretches[k]).some(passes))));
+      // Any of the combinations it alone changes will do, with any conserved amount added (whose
+      // summed balance is zero too): one of them needs a row of its own left to take. (Silver's,
+      // e⁻ − Fe³⁺ beside a closed iron couple that had Fe³⁺'s, is e⁻ + Fe²⁺ with the iron added.)
+      const news = this._conservedMoieties(true, [], rx).filter((w) => Math.abs(nu.reduce((t, x, k) => t + x * w[k], 0)) > 1e-9 && !fed(w));
+      const kept = laws.filter((l) => !fed(l));
+      const tries = [...news, ...news.flatMap((w) => kept.flatMap((l) => [1, -1].map((sg) => w.map((x, m) => x + sg * l[m]))))];
+      for (const w of tries) {
+        const v = new Float64Array(S + T);
+        for (let k = 0; k < S; k++) {
+          if (w[k] === 0) continue;
+          const st = this.stretches[k];
+          if (this._moves(st) && !spectators.has(rowOf(k))) v[k] = w[k];
+          if (this.z[st.species] !== 0) for (const t of driven(st)) v[S + t] = w[k] / this.z[st.species];
+        }
+        for (const [col, row] of chosen) {
+          const fc = v[col];
+          if (fc !== 0) for (let j = 0; j < S + T; j++) v[j] -= fc * row[j];
+        }
+        const scale = v.reduce((m, x) => Math.max(m, Math.abs(x)), 0);
+        if (!(scale > 1e-9)) continue;
+        // (Never a metal's carriers, nor a stretch a terminal feeds, even at no current: their rows
+        // carry the terminal's current, and Pt's electrons standing for an iron couple's balance
+        // put the electrode at 602 V.)
+        const ok = (j) => j !== undefined && j >= 0 && j < S && Math.abs(v[j]) > 1e-9 * scale && !conductor(this.stretches[j]) && this.terms.every((_, t) => !this._feeds(t, this.stretches[j]));
+        // (One of its own species first, then weight 1, the largest, and by name.)
+        const own = (k) => rx.part.some((p) => p.i === this.stretches[k].species && this.stretchOf[(f + p.side) * this.n + p.i] === k);
+        const key = (k) => [own(k) ? 0 : 1, Math.abs(v[k]) === 1 ? 0 : 1, -Math.abs(v[k]), model.species[this.stretches[k].species].name, this.stretches[k].regions[0]];
+        const less = (a, b) => { const ka = key(a), kb = key(b); for (let j = 0; j < ka.length; j++) if (ka[j] !== kb[j]) return ka[j] < kb[j]; return false; };
+        const col = [...Array(S).keys()].filter(ok).reduce((b, k) => (b < 0 || less(k, b) ? k : b), -1);
+        if (col < 0) continue;
+        chosen.push([col, v.map((x) => x / v[col])]);
+        this.affinities.push({ rx, f, row: rowOf(col), idx: new Int32Array(rx.part.length), w: new Float64Array(rx.part.length), len: 0, res: 0 });
+        break;
+      }
+    }
+    for (let w of [...laws.filter(through), ...laws.filter((w) => !through(w))]) {
+      for (const [j, k] of this.carriers.entries()) {
+        const c = held.get(k);
+        if (w[X + j] === 0 || !c) continue;
+        const f = w[X + j] / c[X + j], own = w.own;
+        w = w.map((x, m) => (Math.abs(x - f * c[m]) < 1e-9 ? 0 : x - f * c[m]));
+        w.own = own;
+      }
       const parts = [...w.keys()].filter((k) => k < S && w[k] !== 0).map((k) => ({ stretch: k, w: w[k] }));
-      const surface = [...w.keys()].filter((k) => k >= S && w[k] !== 0).map((k) => ({ col: k - S, w: w[k] }));
-      if (parts.length === 0) continue; // (a surface's own: left to giant time steps)
+      const surface = [...w.keys()].filter((k) => k >= S && k < X && w[k] !== 0).map((k) => ({ col: k - S, w: w[k] }));
+      const carriers = this.carriers.flatMap((k, j) => (w[X + j] !== 0 ? [{ k, w: w[X + j] }] : []));
+      if (parts.length === 0) continue; // (a surface's own: node by node, below)
       if (parts.length === 1 && surface.length === 0 && this.stretches[parts[0].stretch].spectator) continue; // (above)
-      if (parts.some((p) => !this.stretches[p.stretch].mobile || conductor(this.stretches[p.stretch]))) continue;
-      // The row replaced: the basis vector's own stretch (its weight is 1, and no other vector has one).
-      add(parts, parts.find((p) => w[p.stretch] === 1)?.stretch ?? parts[0].stretch, surface);
-    }
-    // A combination of immobile stretches (trap states: X⁰ + X⁻ under e⁻ + X⁰ = X⁻) is conserved
-    // node by node, since nothing carries it anywhere: at each node its weighted sum stays what
-    // it was, a row local to that node's block, in place of the balance row of one of them.
+      if (parts.some((p) => !this._moves(this.stretches[p.stretch]) && !this._still(this.stretches[p.stretch]))) continue;
+      const v = new Float64Array(S + T);
+      for (const { stretch: k, w: wk } of parts) {
+        const st = this.stretches[k];
+        if (this._moves(st) && !spectators.has(rowOf(k))) v[k] = wk;
+        if (this.z[st.species] !== 0) for (const t of driven(st)) v[S + t] = wk / this.z[st.species];
+      }
+      for (const { k, w: wk } of carriers) v[S + k] = wk / zc(k);
+      for (const [col, row] of chosen) {
+        const f = v[col];
+        if (f !== 0) for (let j = 0; j < S + T; j++) v[j] -= f * row[j];
+      }
+      const scale = v.reduce((m, x) => Math.max(m, Math.abs(x)), 0);
+      if (!(scale > 1e-9)) continue;
+      const ok = (j) => j !== undefined && Math.abs(v[j]) > 1e-9 * scale;
+      const col = [...Array(T).keys()].map((t) => S + t).find(ok) ?? [parts.find((p) => w[p.stretch] === 1)?.stretch, w.own].find(ok) ?? v.findIndex((x) => Math.abs(x) === scale);
+      if (carriers.some((p) => p.k !== col - S)) continue; // (an electrode's charge in a circuit row not its own: never, as they're chosen)
+      chosen.push([col, v.map((x) => x / v[col])]);
+      if (col >= S) held.set(col - S, w);
+      add(parts, col < S ? col : parts[0].stretch, surface, col < S ? -1 : col - S, carriers);
+    }
+    // A combination that nothing carries anywhere is conserved node by node: of still stretches
+    // (trap states: X⁰ + X⁻ under e⁻ + X⁰ = X⁻), or of an electrode's surface species (adsorbates
+    // that only turn into each other). At each node its weighted sum stays what it was, a row local
+    // to that node's block, in place of one of their balances.
     this.localConstraints = [];
-    const immobile = (st) => {
-      for (let q = st.regions[0]; q <= st.regions[1]; q++) if (materials[regions[q].material].D[st.species] > 0) return false;
-      return true;
-    };
-    for (const w of this.moieties) {
-      const parts = [...w.keys()].filter((k) => w[k] !== 0).map((k) => ({ stretch: k, w: w[k] }));
-      const sts = parts.map((p) => this.stretches[p.stretch]);
-      if (sts.some((st) => st.conserved || !immobile(st) || conductor(st))) continue;
-      if (sts.some((st) => st.nodes[0] !== sts[0].nodes[0] || st.nodes[1] !== sts[0].nodes[1])) continue; // (side by side only)
-      for (const st of sts) st.conserved = true;
-      const row = parts.find((p) => p.w === 1) ?? parts[0];
+    const span = ([g0, g1]) => Array.from({ length: g1 - g0 + 1 }, (_, j) => g0 + j);
+    for (const w of laws) {
+      const parts = [...w.keys()].filter((k) => w[k] !== 0);
+      if (parts.some((k) => k >= X)) continue; // (through an electrode: above)
+      const sets = parts.map((k) => (k >= S ? model.ports[this.surfCols[k - S][0]].nodes : this._still(this.stretches[k]) ? span(this.stretches[k].nodes) : null));
+      if (sets.some((set) => set === null || set.length !== sets[0].length || set.some((g, j) => g !== sets[0][j]))) continue; // (side by side only)
+      for (const k of parts) if (k < S) this.stretches[k].conserved = true;
+      const slot = (k) => (k < S ? 1 + this.stretches[k].species : 1 + this.n + this.surfCols[k - S][1]);
       this.localConstraints.push({
-        parts: parts.map((p) => ({ i: this.stretches[p.stretch].species, w: p.w })),
-        row: 1 + this.stretches[row.stretch].species,
-        nodes: sts[0].nodes,
-        reference: new Float64Array(sts[0].nodes[1] - sts[0].nodes[0] + 1),
+        parts: parts.map((k) => (k < S ? { i: this.stretches[k].species, w: w[k] } : { q: this.surfCols[k - S][1], w: w[k] })),
+        row: slot(parts.includes(w.own) ? w.own : parts[0]),
+        nodes: sets[0],
+        reference: new Float64Array(sets[0].length),
       });
     }
     // Islands: the pieces of a stretch between its faces. One that nothing else feeds (no
@@ -821,7 +1014,7 @@ export class Solver {
     this.pinnedIslands = [];
     this.islandsOn = false; // (newton() turns them on, see there)
     this.pins = [];
-    const used = new Set(this.constraints.map((cs) => cs.row));
+    const used = new Set([...this.constraints.map((cs) => cs.row).filter((o) => o >= 0), ...this.affinities.map((af) => af.row)]);
     for (const st of this.stretches) {
       const i = st.species, [s0, s1] = st.regions;
       if (!st.mobile || conductor(st)) continue;
@@ -870,19 +1063,68 @@ export class Solver {
       }
     }
     for (const isl of this.islands) isl.outside = isl.outside.filter((o) => !used.has(o));
-    this.constrained = false;
+
+    // Time steps only: a terminal behind a resistance that alone feeds a combination reads its
+    // current by that combination's change too (see _circuitLaws), its combinations found with it
+    // counted as driven by a current. (Not in the steady system, where it holds its level.)
+    this.timeLaws = [];
+    const behind = this.floating.filter((k) => this.terms[k].drive.kind !== 'I');
+    if (behind.length > 0) {
+      const steadyCarriers = this.carriers, more = this._conservedMoieties(true, behind), X2 = S + this.surfCols.length;
+      for (const w of more) {
+        const parts = [...w.keys()].filter((k) => k < S && w[k] !== 0).map((k) => ({ stretch: k, w: w[k] }));
+        if (parts.length === 0 || parts.some((p) => !this._moves(this.stretches[p.stretch]) && !this._still(this.stretches[p.stretch]))) continue;
+        const surface = [...w.keys()].filter((k) => k >= S && k < X2 && w[k] !== 0).map((k) => ({ col: k - S, w: w[k] }));
+        const carriers = this.carriers.flatMap((k, j) => (w[X2 + j] !== 0 ? [{ k, w: w[X2 + j] }] : []));
+        // Fed by one terminal behind a resistance and nothing else that passes current.
+        const fedBy = new Set([...carriers.map((p) => p.k), ...parts.flatMap((p) => this.floating.filter((k) => this._feeds(k, this.stretches[p.stretch])))]);
+        if (fedBy.size !== 1) continue;
+        const [k] = fedBy;
+        if (!behind.includes(k) || this.timeLaws.some((cs) => cs.circuit === k)) continue;
+        const zc = k >= 2 ? this.z[model.ports[k - 2].terminal] : 0;
+        const lambda = carriers.find((p) => p.k === k)?.w / zc || parts.map((p) => (this._feeds(k, this.stretches[p.stretch]) && this.z[this.stretches[p.stretch].species] !== 0 ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0);
+        if (!lambda) continue;
+        let nNodes = parts.reduce((m, p) => m + this.stretches[p.stretch].nodes[1] - this.stretches[p.stretch].nodes[0] + 1, 0);
+        for (const p of surface) nNodes += model.ports[this.surfCols[p.col][0]].nodes.length * model.ports[this.surfCols[p.col][0]].surface.length;
+        for (const p of carriers) nNodes += model.ports[p.k - 2].nodes.length;
+        this.timeLaws.push({ parts, surface, carriers, terminals: [k], circuit: k, lambda, idx: new Int32Array(nNodes * this.M), w: new Float64Array(nNodes * this.M), len: 0 });
+      }
+      this.carriers = steadyCarriers;
+    }
+  }
+
+  // What each combination fed by a terminal driven at no current holds now, which a steady solve
+  // keeps: a closed battery at open circuit stays at the charge it had.
+  _captureLaws() {
+    // A terminal at no current that passes current only by charging a capacitance keeps its charge.
+    this.chargeRefs.clear();
+    const charged = this.floating.filter((k) => this.terms[k].drive.kind === 'I' && this._chargeOnly(k));
+    if (charged.length > 0) {
+      this._assembleBookkeeping(Infinity);
+      for (const k of charged) this.chargeRefs.set(k, k >= 2 ? this.portQ[k - 2] : k === 0 ? this.contactD.left : -this.contactD.right);
+    }
+    this.lawRefs.clear();
+    if (this.constraints.some((cs) => cs.carriers.some(({ k }) => this.model.ports[k - 2].capacitance)) && charged.length === 0) this._assembleBookkeeping(Infinity);
+    for (const cs of this.constraints) {
+      if (cs.terminals.length === 0) continue;
+      let a = 0;
+      for (const { stretch, w } of cs.parts) a += w * this.amount(this.stretches[stretch]);
+      for (const { col, w } of cs.surface) a += w * this.surfaceAmount(col);
+      for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQ[k - 2]) / (this.z[this.model.ports[k - 2].terminal] * FARADAY);
+      this.lawRefs.set(cs.key, a);
+    }
   }
 
   // Each local constraint's weighted sum at each node, as the state holds it now: what a steady
   // solve keeps.
   _captureLocal() {
-    const { n, c } = this;
+    const { n, c, th, nSurf } = this;
     for (const lc of this.localConstraints) {
-      for (let g = lc.nodes[0]; g <= lc.nodes[1]; g++) {
+      lc.nodes.forEach((g, j) => {
         let t = 0;
-        for (const { i, w } of lc.parts) t += w * c[g * n + i];
-        lc.reference[g - lc.nodes[0]] = t;
-      }
+        for (const { i, q, w } of lc.parts) t += w * (i !== undefined ? c[g * n + i] : th[g * nSurf + q]);
+        lc.reference[j] = t;
+      });
     }
   }
 
@@ -892,7 +1134,7 @@ export class Solver {
   _applyIslands() {
     const { u, res } = this, R = this.rix, out = [];
     for (const isl of this.islands) {
-      if (this.flattening && this.flatStretches.includes(isl.stretch)) continue;
+      if (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
@@ -953,34 +1195,55 @@ export class Solver {
 
   // The local constraints' rows (steady solves only): Σ w c_i − reference at each node.
   _applyLocalConstraints() {
-    const { n, M, c, res, dA: d } = this;
+    const { n, M, c, th, nSurf, res, dA: d } = this;
     for (const lc of this.localConstraints) {
-      for (let g = lc.nodes[0]; g <= lc.nodes[1]; g++) {
+      lc.nodes.forEach((g, j) => {
         const b = this.blockOfNode[g];
-        if (this.loc[b * M + lc.row] < 0) continue;
+        if (this.loc[b * M + lc.row] < 0) return;
         this._replaceRow(b, lc.row);
         let t = 0;
-        for (const { i, w } of lc.parts) {
-          t += w * c[g * n + i];
-          this._dc(g, i, d);
-          for (let s = 0; s < M; s++) if (d[s] !== 0) this._j(b, lc.row, b, s, w * d[s]);
+        for (const { i, q, w } of lc.parts) {
+          if (i !== undefined) {
+            t += w * c[g * n + i];
+            this._dc(g, i, d);
+            for (let s = 0; s < M; s++) if (d[s] !== 0) this._j(b, lc.row, b, s, w * d[s]);
+            continue;
+          }
+          // A coverage, with ∂θ_q/∂η_x = θ_q (δ_qx − θ_x) over its surface's species.
+          const tq = th[g * nSurf + q], ns = this.model.ports[this.surfPort[g]].surface.length;
+          t += w * tq;
+          for (let x = 0; x < ns; x++) this._j(b, lc.row, b, 1 + n + x, w * tq * ((q === x ? 1 : 0) - th[g * nSurf + x]));
         }
-        res[this.rix[b * M + lc.row]] = t - lc.reference[g - lc.nodes[0]];
-      }
+        res[this.rix[b * M + lc.row]] = t - lc.reference[j];
+      });
     }
   }
 
   // A basis of the conserved combinations of stretch amounts: the null space of the
-  // stoichiometry (a row per reaction, over the stretches it touches) together with a unit row
-  // for each stretch fed from outside. Exact integer data, so plain elimination will do.
-  _conservedMoieties() {
-    const { model, n } = this, S = this.stretches.length, C = S + this.surfCols.length;
-    const rows = [];
+  // stoichiometry (a row per reaction, over the stretches it touches) together with what the
+  // terminals feed. A terminal held at a voltage (or behind a resistance, which holds it at
+  // steady state) feeds each stretch it links freely: a unit row. With `drives`, one driven by a
+  // current feeds its charged species only as that current allows, in proportion to their
+  // charges, so a combination weighted by z there is conserved while it passes none: a battery's
+  // cathode, its electrons behind an open circuit, keeps its charge. Exact integer data, so plain
+  // elimination will do.
+  _conservedMoieties(drives = false, alsoCurrent = [], skip = null) {
+    const { model, n, z } = this, S = this.stretches.length;
+    // With `drives`, an electrode port driven by a current whose reactions take its carrier from
+    // the electrode has a column of its own, last: what the electrode holds, its charge Q/(zF),
+    // which the current feeds and the reactions draw on (a port at no current with M⁺ + e⁻ = M(s)
+    // keeps M⁺ + Q/F, or with no capacitance, Q = 0, the M⁺ alone).
+    const byCurrent = (t, k) => t.drive.kind === 'I' || alsoCurrent.includes(k); // (with `alsoCurrent`, terminals counted as such)
+    this.carriers = drives ? this.terms.flatMap((t, k) => (byCurrent(t, k) && k >= 2 && model.ports[k - 2].reactions.length > 0 ? [k] : [])) : [];
+    const X = S + this.surfCols.length, C = X + this.carriers.length;
+    // (With `skip`, a reaction left out: the combinations that it alone changes come out too, and
+    // its own rows, over the columns, are handed back as `basis.skipped`.)
+    const rows = [], skipped = [];
     model.interfaces.forEach((itf, f) => {
       for (const rx of itf.reactions) {
         const row = new Float64Array(C);
         for (const p of rx.part) row[this.stretchOf[(f + p.side) * n + p.i]] += p.nu;
-        rows.push(row);
+        (rx === skip ? skipped : rows).push(row);
       }
     });
     // An electrode surface's species are columns too, after the stretches (S + j for surface
@@ -989,11 +1252,13 @@ export class Solver {
     model.ports.forEach((port, k) => {
       for (const rx of port.reactions) {
         const row = new Float64Array(C); // (the electrode's carrier is outside the device)
+        if (rx === skip) skipped.push(row);
         for (const p of rx.part) {
           if (p.side === 0) row[this.stretchOf[port.region * n + p.i]] += p.nu;
           else if (p.side === 2) row[S + this.surfColOf[k] + p.s] += p.nu;
+          else if (this.carriers.includes(k + 2)) row[X + this.carriers.indexOf(k + 2)] += p.nu;
         }
-        rows.push(row);
+        if (rx !== skip) rows.push(row);
       }
     });
     model.regions.forEach((reg, q) => {
@@ -1002,19 +1267,35 @@ export class Solver {
         const row = new Float64Array(C);
         for (const p of rx.reactants) row[this.stretchOf[q * n + p.i]] -= p.nu;
         for (const p of rx.products) row[this.stretchOf[q * n + p.i]] += p.nu;
-        rows.push(row);
+        (rx === skip ? skipped : rows).push(row);
       }
     });
-    this.stretches.forEach((st, k) => {
-      if (!st.contactFed) return;
+    const unit = (k) => {
       const row = new Float64Array(C);
       row[k] = 1;
       rows.push(row);
+    };
+    this.terms.forEach((t, k) => {
+      const fed = this.stretches.flatMap((st, j) => (this._feeds(k, st) ? [j] : []));
+      if (!(drives && byCurrent(t, k))) return fed.forEach(unit);
+      const charged = fed.filter((j) => z[this.stretches[j].species] !== 0).map((j) => [j, z[this.stretches[j].species]]);
+      if (this.carriers.includes(k)) charged.push([X + this.carriers.indexOf(k), z[model.ports[k - 2].terminal]]);
+      fed.filter((j) => z[this.stretches[j].species] === 0).forEach(unit);
+      for (let a = 1; a < charged.length; a++) {
+        const row = new Float64Array(C);
+        row[charged[0][0]] = 1 / charged[0][1];
+        row[charged[a][0]] = -1 / charged[a][1];
+        rows.push(row);
+      }
     });
-    // Reduced row echelon form; the free columns give the null space.
+    // Reduced row echelon form; the free columns give the null space. Immobile stretches' columns
+    // go first, so that a combination of them alone (trap states, X⁰ + X⁻) comes out on its own,
+    // to be kept node by node, apart from any that moves (e⁻ − X⁰, the electrons the traps hold).
+    const order = [...Array(C).keys()].sort((a, b) => (b < S && this._still(this.stretches[b])) - (a < S && this._still(this.stretches[a])));
     const pivots = [];
     let r = 0;
-    for (let col = 0; col < C && r < rows.length; col++) {
+    for (const col of order) {
+      if (r >= rows.length) break;
       let best = r;
       for (let i = r + 1; i < rows.length; i++) if (Math.abs(rows[i][col]) > Math.abs(rows[best][col])) best = i;
       if (Math.abs(rows[best][col]) < 1e-9) continue;
@@ -1040,8 +1321,10 @@ export class Solver {
         const v = -rows[i][free];
         w[col] = Math.abs(v) < 1e-9 ? 0 : v;
       });
+      w.own = free; // (its weight is 1 there, and no other vector's is: the row it replaces)
       basis.push(w);
     }
+    basis.skipped = skipped;
     return basis;
   }
 
@@ -1056,39 +1339,19 @@ export class Solver {
   // sum of the others. That row is dense, so it's kept aside: the factorised matrix gets a pin
   // (identity row) there instead, and _solveBordered restores the constraint.
   _applyConstraints() {
-    const { n, M, res, c, dA: d } = this;
-    const vol = this.model.grid.vol;
+    const { M, res } = this;
     for (const cs of this.constraints) {
-      let amount = 0, reference = 0, len = 0;
-      for (const { stretch, w } of cs.parts) {
-        const st = this.stretches[stretch], i = st.species;
-        reference += w * this.referenceAmounts[stretch];
-        for (let g = st.nodes[0]; g <= st.nodes[1]; g++) {
-          amount += w * vol[g] * c[g * n + i];
-          this._dc(g, i, d);
-          const b = this.blockOfNode[g];
-          for (let r = 0; r < M; r++) {
-            if (d[r] === 0 || this.loc[b * M + r] < 0) continue;
-            cs.idx[len] = this.rix[b * M + r];
-            cs.w[len++] = w * vol[g] * d[r];
-          }
-        }
-      }
-      // What the electrodes' surfaces hold of it: Γ Σ v·a·θ, with ∂θ_s/∂η_x = θ_s (δ_sx − θ_x).
-      for (const { col, w } of cs.surface) {
-        const [k, q] = this.surfCols[col], port = this.model.ports[k], G = port.surface[0].capacity, ns = port.surface.length;
-        reference += w * this.surfaceRef[col];
-        port.nodes.forEach((g, j) => {
-          const f = w * G * vol[g] * this.portArea[k][j], b = this.blockOfNode[g], tq = this.th[g * this.nSurf + q];
-          amount += f * tq;
-          for (let x = 0; x < ns; x++) {
-            cs.idx[len] = this.rix[b * M + 1 + n + x];
-            cs.w[len++] = f * tq * ((q === x ? 1 : 0) - this.th[g * this.nSurf + x]);
-          }
-        });
+      const { amount, reference, dV } = this._lawAmount(cs);
+      cs.res = amount - (cs.terminals.length > 0 ? (this.lawRefs.get(cs.key) ?? amount) : reference);
+      if (cs.circuit >= 0) {
+        // In place of the terminal's circuit row (its I = 0).
+        const C = this.termC[cs.circuit];
+        C.fill(0);
+        for (let j = 0; j < cs.len; j++) C[cs.idx[j]] += cs.w[j];
+        this.termRes[cs.circuit] = cs.res;
+        this.termDI[cs.circuit] = dV;
+        continue;
       }
-      cs.len = len;
-      cs.res = amount - reference;
       const b0 = Math.floor(cs.row / M), r0 = cs.row % M;
       this._replaceRow(b0, r0);
       this._j(b0, r0, b0, r0, 1);
@@ -1096,6 +1359,122 @@ export class Solver {
     }
   }
 
+  // A conserved combination's amount as the state holds it (and its reference, closed), with its
+  // derivatives in cs.idx/w (and dV, by the voltage of a terminal whose electrode's charge it
+  // counts).
+  _lawAmount(cs) {
+    const { n, M, c, dA: d } = this;
+    const vol = this.model.grid.vol;
+    let amount = 0, reference = 0, len = 0, gross = 0;
+    for (const { stretch, w } of cs.parts) {
+      const st = this.stretches[stretch], i = st.species;
+      if (cs.terminals.length === 0) reference += w * this.referenceAmounts[stretch];
+      for (let g = st.nodes[0]; g <= st.nodes[1]; g++) {
+        amount += w * vol[g] * c[g * n + i];
+        gross += Math.abs(w * vol[g] * c[g * n + i]);
+        if (this.nodeConductor[g] >= 0) {
+          // A metal's carriers: the sheet at a charged face, vol·c = ±D_f·A/(zF), held by the
+          // face's displacement.
+          const f = this.sheetFace[g];
+          if (f >= 0 && this.loc[this.blockOfFace[f] * M] >= 0) {
+            cs.idx[len] = this.rix[this.blockOfFace[f] * M];
+            cs.w[len++] = (w * this.sheetSign[g] * this.model.grid.area[g]) / (this.z[i] * FARADAY);
+          }
+          continue;
+        }
+        this._dc(g, i, d);
+        const b = this.blockOfNode[g];
+        for (let r = 0; r < M; r++) {
+          if (d[r] === 0 || this.loc[b * M + r] < 0) continue;
+          cs.idx[len] = this.rix[b * M + r];
+          cs.w[len++] = w * vol[g] * d[r];
+        }
+      }
+    }
+    // What the electrodes' surfaces hold of it: Γ Σ v·a·θ, with ∂θ_s/∂η_x = θ_s (δ_sx − θ_x).
+    for (const { col, w } of cs.surface) {
+      const [k, q] = this.surfCols[col], port = this.model.ports[k], G = port.surface[0].capacity, ns = port.surface.length;
+      if (cs.terminals.length === 0) reference += w * this.surfaceRef[col];
+      port.nodes.forEach((g, j) => {
+        const f = w * G * vol[g] * this.portArea[k][j], b = this.blockOfNode[g], tq = this.th[g * this.nSurf + q];
+        amount += f * tq;
+        gross += Math.abs(f * tq);
+        for (let x = 0; x < ns; x++) {
+          cs.idx[len] = this.rix[b * M + 1 + n + x];
+          cs.w[len++] = f * tq * ((q === x ? 1 : 0) - this.th[g * this.nSurf + x]);
+        }
+      });
+    }
+    // What an electrode holds, its charge Q/(zF) on the port's capacitance (none without one),
+    // Q = Σ vol·a·C (V − zeroCharge − φ) over its nodes (as _portCapacitance has it).
+    let dV = 0;
+    for (const { k, w } of cs.carriers) {
+      const port = this.model.ports[k - 2];
+      if (!port.capacitance) continue;
+      const f = w / (this.z[port.terminal] * FARADAY), { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k];
+      const sets = (side) => ['pinned', 'bulk'].includes(this.model.contacts[side].phi.type);
+      port.nodes.forEach((g, j) => {
+        if ((g === 0 && sets('left')) || (g === this.nNodes - 1 && sets('right')) || this.phiUndefined[g]) return;
+        const b = this.blockOfNode[g], s = vol[g] * this.portArea[k - 2][j] * Cs;
+        amount += f * s * (V - zeroCharge - this.VT * (this.u[b * M] + this.uLo[b * M]));
+        gross += Math.abs(f * s * (V - zeroCharge - this.VT * (this.u[b * M] + this.uLo[b * M])));
+        dV += f * s;
+        cs.idx[len] = this.rix[b * M];
+        cs.w[len++] = -f * s * this.VT;
+      });
+    }
+    cs.len = len;
+    return { amount, reference, dV, gross };
+  }
+
+  // The same amount at the step's start, as the storage terms have it (BDF2's c* included).
+  _lawStart(cs) {
+    const { n, nSurf } = this, vol = this.model.grid.vol;
+    let a = 0;
+    for (const { stretch, w } of cs.parts) {
+      const st = this.stretches[stretch], i = st.species;
+      for (let g = st.nodes[0]; g <= st.nodes[1]; g++) a += w * vol[g] * this.cOld[g * n + i];
+    }
+    for (const { col, w } of cs.surface) {
+      const [k, q] = this.surfCols[col], port = this.model.ports[k], G = port.surface[0].capacity;
+      port.nodes.forEach((g, j) => (a += w * G * vol[g] * this.portArea[k][j] * this.thOld[g * nSurf + q]));
+    }
+    for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQStart[k - 2]) / (this.z[this.model.ports[k - 2].terminal] * FARADAY);
+    return a;
+  }
+
+  // Time steps: a terminal driven by a current that alone feeds a conserved combination can read
+  // its current as the combination's change, F (S − S*)/(λ dt), which the step's balance rows sum
+  // to exactly, rather than as the flux through it. Both are exact; they differ in round-off and
+  // in what Newton can see. Through a metal, the flux is G Δη, its two η all but equal: a floating
+  // gate's charging current fell below that at steps of ~0.03 s, and the step came out singular.
+  // Over long steps the change is the better kept (a closed host at open circuit, read by its
+  // flux, drifted from its charge by 3 mV over 5e11 s, and its steps failed by 4e12 s). Over
+  // short ones it's the amount's round-off over dt (a battery's cathode holds 0.04 mol/m² of
+  // electrons: 1e-6 A/m² at steps of 1e-6 s, enough to reject steps at tol 1e-8), where the flux,
+  // its levels carried in two words (u + uLo), is far cleaner than ε G. So a step reads the change
+  // where that's ε·F·S/(λ dt) below 1e-6 of the flux's ε G, as its start has them, keeps to it
+  // throughout, and where a step read by the flux fails, it's tried once more read by the change
+  // (see step).
+  _circuitLaws(dt) {
+    for (const cs of [...this.constraints, ...this.timeLaws]) {
+      const k = cs.circuit;
+      if (k < 0 || !this.floating.includes(k)) continue;
+      const { amount, dV, gross } = this._lawAmount(cs), f = FARADAY / (cs.lambda * dt), C = this.termC[k];
+      if (!this.lawForm.has(cs)) {
+        let G = 0;
+        for (let j = 0; j < C.length; j++) G = Math.max(G, Math.abs(C[j]));
+        this.lawForm.set(cs, Math.abs(f) * gross < 1e-6 * G);
+      }
+      if (!this.lawForm.get(cs)) continue;
+      C.fill(0);
+      for (let j = 0; j < cs.len; j++) C[cs.idx[j]] += f * cs.w[j];
+      const d = this.terms[k].drive, src = sourceAt(d.src, this.sourceTime, this.sourceBefore);
+      this.termRes[k] = f * (amount - this._lawStart(cs)) - (d.kind === 'I' ? src : (src - this.termV[k]) / d.R);
+      this.termDI[k] = f * dV + (d.kind === 'I' ? 0 : 1 / d.R);
+    }
+  }
+
   // 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 rows pinned in T: the spectators' conserved amounts (see _applyConstraints) and the
@@ -1114,10 +1493,11 @@ export class Solver {
     for (let a = 0; a < S; a++) {
       if (!cols[a]) cols[a] = new Float64Array(N + 1);
       if (a < P) {
-        const row = this.rix[pins[a].row];
-        e[row] = 1;
+        // The response to a unit pin, or where the pin moves a flat stretch, to its shift.
+        const col = pins[a].col ?? [pins[a].row];
+        for (const o of col) e[this.rix[o]] = 1;
         this._solveLinear(e, cols[a]);
-        e[row] = 0;
+        for (const o of col) e[this.rix[o]] = 0;
       } else this._solveLinear(this.termB[fl[a - P]], cols[a]);
     }
     // Row a of the small system, as a dot product with a compact vector (sparse for pins).
@@ -1194,13 +1574,72 @@ export class Solver {
   // change of source is a discontinuity, so time stepping restarts its order.
   redrive() {
     this.atSteady = false;
-    const before = this.floating;
+    const before = this.floating, driven = this.drivenKey;
     this.floating = this.terms.flatMap((t, k) => (t.drive.kind === 'I' || t.drive.R > 0 ? [k] : []));
     if (this.floating.length !== before.length) this.deltaV = null;
+    // A terminal newly driven by a current (or no longer) can close a combination behind it.
+    // (and one put behind a resistance, or taken from it, its time steps' reading: see _laws)
+    this.drivenKey = this._drivenKey();
+    if (this.drivenKey !== driven) this._laws();
     this._refreshSources();
     this.history = [];
   }
 
+  // After a steady solve: each reaction that alone changes some combination nothing else feeds
+  // (see _laws), whose total rate a steady state therefore sets to zero, but whose affinity has one
+  // sign wherever it acts, so that its total can't be zero. Too slow to show, its rate lost to
+  // round-off, it was left where the solve began: a slow complexation 43 mV off, an electrode
+  // port's slow couple at its starting composition, each converged without a word. (A face
+  // reaction stands on its affinity, so it's only caught here if that couldn't be arranged.)
+  stuckReactions() {
+    const { n, M, u, uLo, model } = this, grid = model.grid, S = this.stretches.length, X = S + this.surfCols.length, out = [];
+    const passes = (k) => !this._noCurrent(this.terms[k]);
+    const fed = (w) => w.some((x, k) => x !== 0 && ((k >= X && passes(this.carriers[k - X])) || (k < S && this.terms.some((t, j) => t.drive.kind === 'I' && passes(j) && this._feeds(j, this.stretches[k])))));
+    const needed = (rx) => {
+      const basis = this._conservedMoieties(true, [], rx);
+      return basis.some((w) => !fed(w) && basis.skipped.some((row) => Math.abs(row.reduce((t, x, k) => t + x * w[k], 0)) > 1e-9));
+    };
+    const eta = (g, slot) => u[this.blockOfNode[g] * M + slot] + uLo[this.blockOfNode[g] * M + slot];
+    const report = (where, as) => {
+      if (as.length === 0 || !(as.every((a) => a > 1e-6) || as.every((a) => a < -1e-6))) return;
+      out.push({ where, affinity: as.reduce((m, a) => (Math.abs(a) < Math.abs(m) ? a : m)) });
+    };
+    model.interfaces.forEach((itf, f) => {
+      const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1];
+      itf.reactions.forEach((rx, q) => {
+        if (this.affinities.some((af) => af.rx === rx) || !needed(rx)) return;
+        report(`interfaces[${f}].reactions[${q}]`, [rx.part.reduce((a, p) => a - p.nu * eta(p.side ? gR : gL, 1 + p.i), rx.fixedA)]);
+      });
+    });
+    model.reactions.forEach((mrx, x) => {
+      const rx = this.rxs[x];
+      if (rx.generation || !needed(mrx)) return;
+      const as = [];
+      for (let g = 0; g < this.nNodes; g++) if (rx.kfNode[g] > 0 || rx.srh?.[this.nodeMaterial[g]]) as.push(rx.sp.reduce((a, i, p) => a + rx.nu[p] * eta(g, 1 + i), rx.fixedA));
+      report(`bulkReactions[${x}]`, as);
+    });
+    model.ports.forEach((port, k) => {
+      port.reactions.forEach((rx, q) => {
+        if (!needed(rx)) return;
+        let aV = rx.fixedA;
+        for (const p of rx.part) if (p.side === 1) aV -= p.nu * this.portEta(port, p.i);
+        report(`ports[${k}].reactions[${q}]`, port.nodes.map((g) => rx.part.reduce((a, p) => (p.side === 1 ? a : a - p.nu * eta(g, p.side === 2 ? 1 + n + p.s : 1 + p.i)), aV)));
+      });
+    });
+    return out;
+  }
+
+  // How each terminal is driven, as far as the laws care (see _laws): by a voltage or a current,
+  // behind a resistance or not, and a current that's held at zero throughout (which feeds a
+  // combination nothing, so a reaction's affinity may stand in for its summed balance).
+  _drivenKey() {
+    return this.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}${this._noCurrent(t) ? '0' : ''}`).join();
+  }
+
+  _noCurrent(t) {
+    return t.drive.kind === 'I' && !(t.drive.R > 0) && t.drive.src.value === 0;
+  }
+
   // Held terminals take their sources' values at sourceTime (a floating one keeps its voltage,
   // an unknown; one behind a resistance reads its source voltage in _circuit).
   _refreshSources() {
@@ -1355,11 +1794,15 @@ export class Solver {
       if (!mat.phiFree && !responds && mat.ideal && electrode) {
         // Nor here, but an electrode spread through it does: start with the port's first reaction
         // that can be balanced at equilibrium with the port's level (the electrode at open circuit).
+        const bare = 1 - electrode.surface.reduce((t, sp) => t + sp.theta0, 0);
         for (const rx of electrode.reactions) {
           let a = rx.fixedA, s = 0;
           for (const p of rx.part) {
             if (p.side === 1) a -= p.nu * this.portEta(electrode, p.i);
-            else if (mode[p.i] === 2) {
+            else if (p.side === 2) {
+              const sp = electrode.surface[p.s]; // (at its starting coverage)
+              a -= p.nu * (sp.mu0 / model.RT + Math.log(sp.theta0 / bare));
+            } else if (mode[p.i] === 2) {
               a -= p.nu * (Math.log(cFix[p.i] / mat.cRef[p.i]) + mat.mu0[p.i] / model.RT);
               s += p.nu * z[p.i];
             } else s = NaN;
@@ -1404,6 +1847,31 @@ export class Solver {
         }
       }
     }
+    // An insertion host's φ is a gauge: c0 sets only its neutral combination's level, not how that
+    // splits between its ion and its electrons. Start its ion level with the same ion's beside it
+    // across a face (the equilibrium a link or a transfer reaction heads for), so its electrons,
+    // and a floating contact on them, start where the cell's open-circuit voltage puts them, not
+    // volts away. (A shift of φ̂ and each η by z·Δ: the concentrations don't change.)
+    regions.forEach((reg, r) => {
+      const mat = materials[reg.material];
+      if (!mat.phiFree) return;
+      const sides = [[r - 1, grid.regionStart[r], r > 0 ? grid.regionEnd[r - 1] : -1], [r + 1, grid.regionEnd[r], r + 1 < regions.length ? grid.regionStart[r + 1] : -1]];
+      for (const [nr, gIn, gOut] of sides) {
+        if (gOut < 0) continue;
+        const other = materials[regions[nr].material];
+        if (other.phiFree || other.conductor) continue;
+        const i = z.findIndex((zi, j) => zi !== 0 && mat.present[j] && other.present[j]);
+        if (i < 0) continue;
+        const d = (u[this.blockOfNode[gOut] * M + 1 + i] - u[this.blockOfNode[gIn] * M + 1 + i]) / z[i];
+        if (!Number.isFinite(d)) continue;
+        for (let g = grid.regionStart[r]; g <= grid.regionEnd[r]; g++) {
+          const b = this.blockOfNode[g];
+          u[b * M] += d;
+          for (let j = 0; j < n; j++) if (mat.present[j]) u[b * M + 1 + j] += z[j] * d;
+        }
+        return;
+      }
+    });
     // A floating contact facing a held one starts where the start's own composition puts it: the
     // held voltage plus the difference between the two terminal species' levels beside each
     // contact (c0 sets them, and φ was chosen for neutrality, not to match either contact), so
@@ -1652,6 +2120,7 @@ export class Solver {
     res.fill(0);
     this.dtNow = dt;
     if (this.lin) this.lin.reset(1 / dt);
+    if (this.steady && dt === Infinity) this._snapFlat();
     this.computeConcentrations();
 
     // Regions, each assembled by the kernel for its kind: a conductor (its carrier only), a
@@ -1683,13 +2152,16 @@ 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] : [];
+    if (Number.isFinite(dt) && (this.constraints.length > 0 || this.timeLaws.length > 0)) this._circuitLaws(dt);
+    // The steady system's own rows (see _laws): levels held flat, conserved amounts, islands'
+    // balances, the last two kept aside for _solveBordered.
+    const steady = this.steady && dt === Infinity;
+    if (steady) this._flatRows();
+    if (steady && this.affinities.length > 0) this._applyAffinities();
+    if (steady && this.constraints.length > 0) this._applyConstraints();
+    if (steady && this.localConstraints.length > 0) this._applyLocalConstraints();
+    this.pinnedIslands = steady && this.islandsOn ? this._applyIslands() : [];
+    this.pins = steady ? [...this.constraints.filter((cs) => cs.circuit < 0), ...this.affinities, ...this.pinnedIslands] : [];
     this.transformed = this.combining && dt !== Infinity;
     if (this.transformed) this._chargeRows(dt);
   }
@@ -2536,7 +3008,8 @@ export class Solver {
         const b = this.blockOfNode[g], o = b * M + r, v = vol[g];
         const deta = target - (u[o] + uLo[o]); // (μ̄_out − μ̄)/RT
         if (link.type === 'equilibrium') {
-          if (g === 0 || g === this.nNodes - 1) continue; // a device end node's level is its contact's business
+          // a device end node's level is its contact's business, where the contact links it
+          if ((g === 0 && this.model.contacts.left.species[i].type !== 'blocked') || (g === this.nNodes - 1 && this.model.contacts.right.species[i].type !== 'blocked')) continue;
           flux[i] += res[R[o]];
           this._captureRow(b, r, zF, C);
           this._replaceRow(b, r);
@@ -2678,6 +3151,9 @@ export class Solver {
     const { M, u, uLo, res, VT } = this, R = this.rix, vol = this.model.grid.vol, area = this.portArea[k - 2];
     const { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k], B = this.termB[k], Ct = this.termC[k];
     const sets = (side) => ['pinned', 'bulk'].includes(this.model.contacts[side].phi.type);
+    // Its current, the charging (Q − Q at the step's start)/dt; or, steady at no current, the
+    // charge it keeps in place of that (see _captureLaws).
+    const rate = Number.isFinite(dt) ? 1 / dt : this.steady && this.chargeRefs.has(k) ? 1 : 0;
     let Q = 0, dQdV = 0;
     port.nodes.forEach((g, w) => {
       if ((g === 0 && sets('left')) || (g === this.nNodes - 1 && sets('right')) || this.phiUndefined[g]) return;
@@ -2690,12 +3166,12 @@ export class Solver {
       res[R[b * M]] -= q;
       this._j(b, 0, b, 0, s * VT);
       B[R[b * M]] -= s;
-      if (Number.isFinite(dt)) Ct[R[b * M]] += (-s * VT) / dt;
+      if (rate > 0) Ct[R[b * M]] += -s * VT * rate;
     });
     this.portQ[k - 2] = Q;
-    if (Number.isFinite(dt)) {
-      this.termI[k] += (Q - this.portQStart[k - 2]) / dt;
-      this.termDI[k] += dQdV / dt;
+    if (rate > 0) {
+      this.termI[k] += (Q - (dt < Infinity ? this.portQStart[k - 2] : this.chargeRefs.get(k))) * rate;
+      this.termDI[k] += dQdV * rate;
     }
   }
 
@@ -2816,10 +3292,13 @@ export class Solver {
       this._j(b, 0, b, 0, Ac * link.C * VT);
       B[R[b * M]] += -Ac * link.C;
       this.contactD[side] = sgn * Din;
-      if (dyn) {
-        I += (Din - Dstart) / dt;
-        C[R[b * M]] += (-Ac * link.C * VT) / dt;
-        this.termDI[k] += (Ac * link.C) / dt;
+      // Its current, the charging (D_in − D_in at the step's start)/dt; or, steady at no current,
+      // the charge it keeps in place of that (see _captureLaws).
+      const rate = dyn ? 1 / dt : this.steady && this.chargeRefs.has(k) ? 1 : 0;
+      if (rate > 0) {
+        I += (Din - (dyn ? Dstart : this.chargeRefs.get(k))) * rate;
+        C[R[b * M]] += -Ac * link.C * VT * rate;
+        this.termDI[k] += Ac * link.C * rate;
       }
     } else if (link.type === 'pinned' || link.type === 'bulk') {
       // The Poisson residual is the outside's charge, D_in.
@@ -2828,6 +3307,9 @@ export class Solver {
       if (dyn && !(this.combining && this.lateStorage[g] === 1)) {
         I += (Din - Dstart) / dt;
         this._captureRow(b, 0, 1 / dt, C);
+      } else if (!dyn && this.steady && this.chargeRefs.has(k)) {
+        I += Din - this.chargeRefs.get(k);
+        this._captureRow(b, 0, 1, C);
       }
       this._replaceRow(b, 0);
       if (link.type === 'pinned') {
@@ -2860,12 +3342,42 @@ 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.
+  // A flat stretch's level: its contact's, through the terminal k that holds it, or (reaching
+  // none) its first node's, which its amount fixes (that row is the amount's, a pin whose
+  // response moves the whole stretch: see _applyConstraints).
+  _flatLevel(st) {
+    const { M, u, uLo, z, VT, model } = this, i = st.species;
+    if (st.leftOpen || st.rightOpen) {
+      const side = st.leftOpen ? 'left' : 'right', link = model.contacts[side].species[i], k = side === 'left' ? 0 : 1;
+      return { k, hi: z[i] === 0 ? link.mu / model.RT : (z[i] * (this.termV[k] + link.offset)) / VT, lo: 0 };
+    }
+    const o = this.blockOfNode[st.nodes[0]] * M + 1 + i;
+    return { k: -1, hi: u[o], lo: uLo[o] };
+  }
+
+  // Each flat stretch's nodes set to its first node's level exactly (where Newton's damped
+  // updates have taken it, on the way to its contact's), so that it carries exactly no flux (the
+  // expm1 form of a zero difference). Flat only to round-off, a level moved by its contact had
+  // read as a current: a MOS capacitor's holes, their contact jumped to −6 V, as
+  // 3e-4 A/m² through a bulk that conducts ~1e10 S/m² (the true current was 3.5e-7).
+  _snapFlat() {
+    const { M, u, uLo } = this;
+    for (const st of this.flatStretches) {
+      const f = this.blockOfNode[st.nodes[0]] * M + 1 + st.species, hi = u[f], lo = uLo[f];
+      for (let g = st.nodes[0] + 1; g <= st.nodes[1]; g++) {
+        const o = this.blockOfNode[g] * M + 1 + st.species;
+        if (this.loc[o] < 0) continue;
+        u[o] = hi;
+        uLo[o] = lo;
+      }
+    }
+  }
+
   _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;
+      const i = st.species, open = st.leftOpen || st.rightOpen;
+      const { k, hi, lo } = this._flatLevel(st), level = hi + lo;
       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;
@@ -2873,7 +3385,7 @@ export class Solver {
         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;
+        if (open && 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.
@@ -2889,24 +3401,32 @@ export class Solver {
     }
   }
 
-  // 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]);
+  // Steady solves: each reaction that alone changes a combination (see _laws) held at its
+  // equilibrium, a = fixedA − Σ ν η = 0, in place of one of that combination's balance rows (a pin,
+  // like an amount's).
+  _applyAffinities() {
+    const { M, u, uLo, res } = this, grid = this.model.grid;
+    for (const af of this.affinities) {
+      const b0 = Math.floor(af.row / M), r0 = af.row % M;
+      this._replaceRow(b0, r0);
+      this._j(b0, r0, b0, r0, 1);
+      res[this.rix[af.row]] = 0;
+      const gL = grid.regionEnd[af.f], gR = grid.regionStart[af.f + 1];
+      let hi = af.rx.fixedA, lo = 0, len = 0;
+      for (const p of af.rx.part) {
+        const o = this.blockOfNode[p.side ? gR : gL] * M + 1 + p.i;
+        hi -= p.nu * u[o];
+        lo -= p.nu * uLo[o];
+        if (this.loc[o] < 0) continue;
+        af.idx[len] = this.rix[o];
+        af.w[len++] = -p.nu;
       }
+      af.len = len;
+      af.res = hi + lo;
     }
   }
+
+  // Zero one row of the Jacobian (all three blocks), ready to be replaced.
   _replaceRow(b, rs) {
     const l = this.loc[b * this.M + rs];
     if (l < 0) return;
@@ -2994,6 +3514,11 @@ export class Solver {
       rest.multiply(v, jv);
       if (save.transformed) this._untransform(v); // (the dilute terms in the plain unknowns)
       lin.apply(v, jv, 1, 1 / dt);
+      // A flat stretch's rows hold each level to its first node's (see _flatRows).
+      for (const p of pins) {
+        if (!p.col) continue;
+        for (const o of p.col) if (o !== p.row && this.loc[o] >= 0) jv[R[o]] -= x[R[p.row]];
+      }
       const out = new Float64Array(N + K);
       for (let j = 0; j < N; j++) {
         let t = jv[j];
@@ -3038,8 +3563,13 @@ export class Solver {
       // stops refining.
       const x0 = Float64Array.from(x);
       const ok = gmresReal(op, pb, x, { m: 8, restarts: 1, tol: 1e-8 });
-      let c = 0;
-      for (let j = 0; j < N + K; j++) c = Math.max(c, Math.abs(x[j] - x0[j]));
+      // (Measured on the potentials, as Newton's own step is: a rate the plain solve left
+      // unsolved, at a perturbed pivot, can need a correction of 41.7 mol/(m²·s).)
+      const dx = new Float64Array(N + 1), dV = new Float64Array(K);
+      for (let j = 0; j < N; j++) dx[j] = x[j] - x0[j];
+      for (let a = 0; a < K; a++) dV[a] = x[N + a] - x0[N + a];
+      if (this.transformed) this._untransform(dx);
+      const c = this._maxPotentialStep(dx, dV);
       if (!ok || !(c < 1)) return false;
       for (let j = 0; j < N; j++) delta[j] = x[j];
       for (let a = 0; a < K; a++) deltaV[a] = x[N + a];
@@ -3091,9 +3621,21 @@ export class Solver {
     // A/m² of noise), their rows can throw Newton off instead: if it doesn't converge again
     // within a dozen iterations, the plain solution stands.
     this.islandsOn = islands;
-    let rounds = 0, kept = null;
+    let rounds = 0, kept = null, perturbed = false;
+    // Converged by a small update, but solved at a perturbed pivot, or in a steady solve (where a
+    // factorisation that lost a row's digits left a reaction's rate 3.6e7 off it, the update
+    // small, an I = 0 electrode at a voltage 0.4 V from its steady one): the residual itself,
+    // assembled at the state, must be small too (each row scaled by its largest Jacobian entry).
+    const unsolved = () => {
+      if (!perturbed && dt !== Infinity) return false;
+      this.assemble(dt);
+      this._equilibrate();
+      let r = 0;
+      for (let k = 0; k < this.SINK; k++) r = Math.max(r, Math.abs(this.res[k]));
+      return !(r < 1e-6);
+    };
     const islandsOff = (it, result) => {
-      if (dt !== Infinity || !this.constrained || this.islands.length === 0 || rounds >= 2 || !(this._kirchhoff() > 1e-9)) return false;
+      if (dt !== Infinity || !this.steady || 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) };
@@ -3136,6 +3678,13 @@ export class Solver {
       } catch (err) {
         return fail({ converged: false, iterations: it, history, error: err.message });
       }
+      // A pivot perturbed (one that cancelled to exactly nothing) can leave a row unsolved, its
+      // update small while its residual isn't: the same couple written twice on an electrode at
+      // open circuit converged with one spelling's rate row 41.7 mol/(m²·s) off, the couple
+      // 1.5 RT from equilibrium. Refine the solves (exact J·v) wherever one was, and before
+      // taking a small update for convergence there, look at the residual itself (see unsolved).
+      perturbed = this.sys.perturbedPivots > 0;
+      if (perturbed && !noRefine) refine = true;
       try {
         const pins = this.pins;
         deltaV.fill(0);
@@ -3174,6 +3723,7 @@ export class Solver {
       const last = history[history.length - 2], theta = step / last;
       const contracted = dt !== Infinity && it >= 2 && step < 1e-6 && theta < 0.1 && (theta / (1 - theta)) * step < tol;
       if (alpha === 1 && (step < tol || contracted)) {
+        if (unsolved()) return fail({ converged: false, iterations: it, history, error: 'a row left unsolved at a pivot that cancelled exactly' });
         const done = { converged: true, iterations: it, history, residual: rmax };
         if (islandsOff(it, done)) continue;
         this.computeConcentrations();
@@ -3194,6 +3744,7 @@ export class Solver {
       if (refine) refined++;
       else if (!noRefine && alpha === 1 && it >= 3 && step > 0.25 * p1 && (step < 1e-4 || (step > p1 && p1 > p2))) refine = true;
       if (alpha === 1 && it >= 4 && (!refine || refined >= 1 || noRefine) && step < floor && p1 < floor && step > 0.25 * p1 && p1 > 0.25 * p2) {
+        if (unsolved()) return fail({ converged: false, iterations: it, history, error: 'a row left unsolved at a pivot that cancelled exactly' });
         const done = { converged: true, iterations: it, history, residual: rmax, roundoff: true };
         if (islandsOff(it, done)) continue;
         this.computeConcentrations();
@@ -3227,18 +3778,20 @@ export class Solver {
     }
     if (!(c.digits > (this.conditioning?.digits ?? -1))) return;
     const { grid } = this.model;
-    let x = NaN, where = '';
+    let x = NaN, where = '', nodes = [];
     for (let g = 0; g < this.nNodes; g++) {
       if (this.blockOfNode[g] !== c.block) continue;
       x = grid.x[g];
       where = this.model.regions[grid.nodeRegion[g]].name;
+      nodes = [g];
     }
     for (let f = 0; f < this.nFaces; f++) {
       if (this.blockOfFace[f] !== c.block) continue;
       x = grid.x[grid.regionEnd[f]];
       where = `interfaces[${f}]`;
+      nodes = [grid.regionEnd[f], grid.regionEnd[f] + 1];
     }
-    this.conditioning = { digits: c.digits, x, where };
+    this.conditioning = { digits: c.digits, x, where, nodes };
   }
 
   /**
@@ -3301,11 +3854,7 @@ export class Solver {
       this.portQEnd = Float64Array.from(this.portQ);
     }
     const DN = { ...this.contactDEnd }, QN = Float64Array.from(this.portQEnd);
-    if (opts.guess) {
-      // Start Newton from a predicted state (e.g. extrapolated from the history).
-      this.u.set(opts.guess);
-      this.uLo.fill(0);
-    }
+    if (opts.guess) this._guess(opts.guess); // start Newton from a predicted state
     let dtEff = dt;
     if (bdf) {
       const a0 = (1 + 2 * w) / (1 + w), b1 = (1 + w) / a0, b2 = (w * w) / (1 + w) / a0;
@@ -3328,26 +3877,35 @@ export class Solver {
     // Implicit: sources at the step's end, as seen from within the step (before any jump there).
     // A step landing on a breakpoint ends on it exactly.
     const tEnd = this.landing !== undefined && Math.abs(this.time + dt - this.landing) <= 1e-9 * dt ? this.landing : this.time + dt;
-    this.sourceTime = this.steady ? this.time : tEnd;
+    this.sourceTime = this.steady ? this.steadyAt : tEnd;
     this.sourceBefore = !this.steady;
     this.combining = true;
+    this.lawForm = new Map(); // (see _circuitLaws)
     let result;
     try {
       result = this.newton(dtEff, opts);
-      if (!result.converged && dtEff === Infinity && this.constrained && this.islands.length > 0) {
+      if (!result.converged && dtEff === Infinity && this.steady && 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);
-        }
+        if (opts.guess) this._guess(opts.guess);
         const again = this.newton(dtEff, { ...opts, islands: true });
         result = { ...again, iterations: result.iterations + again.iterations };
       }
+      if (!result.converged && Number.isFinite(dtEff) && [...this.lawForm.values()].some((v) => !v)) {
+        // A terminal read by its flux whose response is lost to round-off (a floating gate's
+        // charging, below its metal's G Δη): once more, read by the change (see _circuitLaws).
+        this.u.set(this.uPrev);
+        this.uLo.set(this.uPrevLo);
+        this.termV.set(this.termVPrev);
+        if (opts.guess) this._guess(opts.guess);
+        for (const cs of this.lawForm.keys()) this.lawForm.set(cs, true);
+        const again = this.newton(dtEff, opts);
+        result = { ...again, iterations: result.iterations + again.iterations };
+      }
     } finally {
       this.combining = false;
     }
@@ -3360,17 +3918,35 @@ export class Solver {
       this.contactDOld = this.contactDStart;
       this.portQOld = this.portQStart;
       this._accumulateBoundaryIntake(dtEff, cN);
+      // (In time, the state is no longer the steady solve's that a continuation would start from.)
+      if (!this.steady) {
+        this.solvedV = undefined;
+        this.stepped = true;
+      }
     } else {
       this.u.set(this.uPrev);
       this.uLo.set(this.uPrevLo);
       this.termV.set(this.termVPrev);
-      this.sourceTime = this.time;
+      this.sourceTime = this.steady ? this.steadyAt : this.time;
       this.computeConcentrations();
     }
     this.sourceBefore = false;
     return result;
   }
 
+  // Newton's unknowns set to a guess (e.g. extrapolated from the history). Only its unknowns: the
+  // other slots never change (see _activeSlots), and among them is a gauge, an insertion host's
+  // φ̂, that nothing pulls back. Extrapolated through steps that grow, it wandered off
+  // geometrically, 147 to 8000 thermal units in a battery's first 100 s and 1e11 by 1e5 s, where
+  // its species' levels (η − zφ̂, summed back by the host's statistics) lost their digits to it.
+  _guess(guess) {
+    const { u, uLo } = this;
+    for (const k of this.fullOf) {
+      u[k] = guess[k];
+      uLo[k] = 0;
+    }
+  }
+
   /**
    * Adaptive time stepping to tEnd: variable-step BDF2 (or backward Euler), with the local error
    * estimated against an explicit predictor through the previous states, and controlled to
@@ -3379,6 +3955,11 @@ export class Solver {
    * animation can call it once per frame; the step size carries over between calls.
    */
   integrate(tEnd, opts = {}) {
+    // tEnd is an absolute time. Not a number at all is an error; a NaN (a first animation frame's
+    // clock, or a time read from a field that doesn't exist) does nothing, and says so.
+    const absolute = `tEnd is the time to reach in s, absolute (the device is at t = ${this.time}, which a solution gives as its time)`;
+    if (typeof tEnd !== 'number') throw new SolverError(`advance(tEnd): ${absolute}; got ${tEnd}`);
+    if (Number.isNaN(tEnd)) return { converged: true, done: false, steps: 0, rejected: 0, iterations: 0, trace: { t: [], current: [], voltage: [] }, stopped: `advance(NaN) did nothing: ${absolute}` };
     const { tol = 1e-3, dtMax = Infinity, budgetMs = Infinity, maxSteps = 100000, method = 'bdf2' } = opts;
     const clock = () => (globalThis.performance ? globalThis.performance.now() : Date.now());
     const start = clock();
@@ -3388,6 +3969,7 @@ export class Solver {
     // Already there (an animation frame with no time to add): nothing to do, and the step size
     // carried to the next call stays as it was.
     if (!(tEnd > this.time)) return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace };
+    const t0 = this.time;
     let dt = this.dtNext ?? opts.dt0 ?? (tEnd - this.time) * 1e-4;
     if (!(dt > 0)) dt = (tEnd - this.time) * 1e-4;
     // The shortest step worth trying: round-off relative to the time, or the device's fastest
@@ -3400,8 +3982,10 @@ export class Solver {
       if (steps + rejected >= maxSteps || clock() - start > budgetMs) break;
       // Within round-off of the end (a target a hair past a breakpoint just landed on, say):
       // snap to it rather than attempt a step of ~1e-13 s, which can't be resolved and, in a
-      // strictly neutral device, fails outright.
-      if (tEnd - this.time <= 1e-10 * Math.abs(tEnd)) {
+      // strictly neutral device, fails outright. Round-off of the time and negligible beside the
+      // interval asked for: by the time alone, a GITT pulse of 0.01 s at t = 1e9 s was skipped
+      // whole (the time moved, nothing else did), and from 1e10 s 17% of a pulse train's charge.
+      if (tEnd - this.time <= 1e-10 * Math.abs(tEnd) && tEnd - this.time <= 1e-9 * (tEnd - t0)) {
         this.time = tEnd;
         break;
       }
@@ -3495,7 +4079,10 @@ export class Solver {
     // Stopped short, other than on the caller's wall-time budget: say where, and why.
     let stopped;
     const at = `advance stopped at t = ${this.time.toPrecision(6)} s of ${tEnd.toPrecision(6)}`;
-    if (failed) stopped = `${at}: a step didn't converge even when shortened to ${dt.toExponential(1)} s. A drive's jump too big for one step (ramp it), a driven current the device can't keep passing (a diode's reverse recovery past its storage time: stop there), or a device the steady solves also find hard.`;
+    // (What usually does it, most likely first. Round 11's agents read the old list, which led
+    // with a drive's jump, as blaming a modest current pulse: a host emptied at its surface, and
+    // an electrode at open circuit with no double layer, held only by a slow reaction.)
+    if (failed) stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. Look for: a host or surface driven to its limit (emptied or filled at its surface by a current it can no longer pass); an electrode at open circuit held only by a slow reaction, with no double-layer capacitance to keep its level (give its face one: phi capacitive); a drive's jump too big for one step (ramp it); a driven current the device cannot keep passing (a diode's reverse recovery past its storage time: stop there); or a device the steady solves also find hard.`;
     else if (this.time < tEnd && steps + rejected >= maxSteps) stopped = `${at}: maxSteps (${maxSteps}) used up (${rejected} of them rejected). Call again to go on, or loosen tol.`;
     return { converged: !failed, done: this.time >= tEnd, steps, rejected, iterations, trace, ...(stopped ? { stopped } : {}) };
   }
@@ -3583,9 +4170,18 @@ export class Solver {
         if (!(r >= 0 && r < regions.length)) fail(`${path}.region: no region ${JSON.stringify(p.region)}`);
         if (!inside(r)) fail(`${path}.x (${p.x} m) is outside region ${JSON.stringify(p.region)}`);
       } else {
-        r = regions.findIndex((_, rr) => inside(rr));
-        if (!(Number.isFinite(p.x) && r >= 0)) fail(`${path}.x must be a position in the device, in m (got ${p.x})`);
+        // At a face, the side where the probe has something to read; both, and it must be told.
+        const has = (rr) => {
+          const mat = this.model.materials[regions[rr].material];
+          return i < 0 ? !mat.conductor && !mat.phiFree : mat.present[i];
+        };
+        const sides = regions.flatMap((_, rr) => (inside(rr) ? [rr] : []));
+        if (!(Number.isFinite(p.x) && sides.length)) fail(`${path}.x must be a position in the device, in m (got ${p.x})`);
+        const able = sides.filter(has);
+        if (able.length > 1) fail(`${path}.x (${p.x} m) is on the face between ${able.map((rr) => JSON.stringify(regions[rr].name)).join(' and ')}: give region, the side to read`);
+        r = able[0] ?? sides[0];
       }
+      if (i >= 0 && !this.model.materials[regions[r].material].present[i]) fail(`${path}: '${p.species}' is absent from region ${JSON.stringify(regions[r].name)}, so there's nothing to read at x = ${p.x} m`);
       let g = grid.regionStart[r];
       while (g + 1 < grid.regionEnd[r] && x[g + 1] < p.x) g++;
       const w = x[g + 1] > x[g] ? (p.x - x[g]) / (x[g + 1] - x[g]) : 0;
@@ -3704,8 +4300,19 @@ export class Solver {
     this.computeConcentrations();
   }
 
+  // What a floating terminal k passes into the device, which its circuit row holds exactly once
+  // converged: the current it's driven by, or (V_source − V)/R behind a resistance (the source
+  // as the last step saw it, before any jump at its end). Read as a flux through a metal instead,
+  // it carried that flux's round-off, G Δη with G huge: a gate behind R read 1.5e-4 off wherever
+  // Newton stopped an update early, and below ~1e-16 A/m², nothing but noise.
+  passedCurrent(k) {
+    const d = this.terms[k].drive, src = sourceAt(d.src, this.time, !this.atSteady);
+    return d.kind === 'I' ? src : (src - this.termV[k]) / d.R;
+  }
+
   // Terminal current toward +x at the right contact, from the last assembly at this state.
   _terminalCurrent() {
+    if (this.floating.includes(1)) return -this.passedCurrent(1);
     let I = 0;
     for (let i = 0; i < this.n; i++) I += FARADAY * this.z[i] * this.contactFlux.right[i];
     const dt = this.lastDt;
@@ -3739,6 +4346,15 @@ export class Solver {
     if (kT < 0) throw new SolverError(`impedance: no terminal named '${terminal}' (${this.terms.map((t) => t.name).join(', ')})`);
     const dT = this.terms[kT].drive;
     if (dT.R > 0) throw new SolverError(`impedance: terminal '${terminal}' has a series resistance; that belongs to the external circuit`);
+    // A small signal returns through the terminals held at a voltage: with every other one driven
+    // by a current (held open), none comes back, and the impedance is infinite (else round-off).
+    const others = this.terms.filter((t, k) => k !== kT);
+    if (others.length && others.every((t) => t.drive.kind === 'I')) {
+      throw new SolverError(
+        `impedance: every other terminal (${others.map((t) => t.name).join(', ')}) is driven by a current, so it is open to a small signal and no current returns through '${terminal}': ` +
+          `its impedance is infinite. Measure at one of those instead (impedance(f, { terminal: '${others[0].name}' }), its voltage against '${terminal}'), or hold one of them at a voltage`,
+      );
+    }
     const N = nB * M, fl = this.floating, K = fl.length;
     this.sourceTime = this.time;
     this.computeConcentrations();
@@ -4290,12 +4906,20 @@ export class Solver {
     if (!Number.isFinite(dt)) return;
     const last = this.model.regions.length - 1;
     const { n, cOld } = this, vol = this.model.grid.vol;
+    // A stretch alone in what a terminal driven by a current feeds takes in what that current
+    // says, which the step kept exactly (see _circuitLaws); the flux through a metal is round-off.
+    const driven = new Map();
+    for (const cs of this.constraints) {
+      if (cs.circuit < 0 || this.terms[cs.circuit].drive.kind !== 'I' || cs.parts.length !== 1 || cs.surface.length || cs.carriers.length) continue;
+      driven.set(cs.parts[0].stretch, (cs.lambda * sourceAt(this.terms[cs.circuit].drive.src, this.sourceTime, this.sourceBefore)) / (cs.parts[0].w * FARADAY));
+    }
     this.stretches.forEach((st, k) => {
       if (!st.connected) return;
       let q = 0;
       if (st.regions[0] === 0) q += this.contactFlux.left[st.species];
       if (st.regions[1] === last) q -= this.contactFlux.right[st.species];
       for (const p of st.ports) q += this.portFlux[p][st.species];
+      if (driven.has(k)) q = driven.get(k);
       let hist = 0;
       for (let g = st.nodes[0]; g <= st.nodes[1]; g++) hist += vol[g] * (cOld[g * n + st.species] - cN[g * n + st.species]);
       this.boundaryIntake[k] += q * dt + hist;
@@ -4325,45 +4949,55 @@ export class Solver {
   }
 
   /**
-   * Steady state.
-   * - If every species stretch is fed by a contact, nothing is conserved on its own, so the
-   *   true steady equations (dt = ∞, no storage term) are solved directly: no slow modes to
-   *   wait out, however slow the physics (e.g. exponentially scarce minority carriers).
-   * - Otherwise backward-Euler steps at a huge dt, whose storage term pins each conserved
-   *   amount exactly; dt keeps growing ×10 while the state still moves.
-   * If Newton fails, dt ramps up from a small value (pseudo-transient continuation) instead.
+   * Steady state: where a transient from the present state ends, found as the solution of the
+   * steady equations (dt = ∞, no storage term), with no slow modes to wait out, however slow the
+   * physics (e.g. exponentially scarce minority carriers). What the storage term held is held by
+   * the steady system's own rows instead (see _laws): each conserved amount in place of a balance
+   * row that says nothing new, levels that carry nothing held flat, islands' summed balances.
+   * Where Newton from here fails: continuation along the drives, then the pseudo-transient ramp.
    * The clock is not advanced, and open-system conservation bookkeeping restarts here.
    */
   // 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)
+    this.charging = null; // (a driven current that only charges: see _solveSteadyAll)
+    this._captureLaws();
+    this.steady = true; // (the steady system's rows; sources at the present time)
+    this.steadyAt = this.time; // (which a pseudo-transient's steps don't move on)
     try {
       return this._solveSteadyAll(opts);
     } finally {
-      this.flattening = false;
+      this.steady = 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.
-    const { species } = this.model, ions = (links) => links.some((l, i) => l.type !== 'blocked' && species[i].z !== 0);
+    // A terminal driven by a current that can only store what comes in (a battery's cathode
+    // behind it, closed but for that terminal; a gate, or a capacitance with no species through
+    // it) has no steady state but at no current, where it keeps what it holds.
+    const { species, regions } = this.model;
     for (const k of this.floating) {
-      const t = this.terms[k];
-      if (t.drive.kind !== 'I') continue;
-      const only = t.kind === 'port' ? (p) => p.reactions.length === 0 && !ions(p.species) : (c) => !ions(c.species);
-      if (only(t.kind === 'port' ? this.model.ports[t.index] : this.model.contacts[t.side])) {
-        throw new DeviceError(`${t.kind === 'port' ? `ports[${t.index}]` : `contacts.${t.side}`} passes current only by charging, so driven by a current it has no steady state; hold it at V (or a source behind R), or advance() in time`);
-      }
+      const I = sourceAt(this.terms[k].drive.src, this.time);
+      if (this.terms[k].drive.kind !== 'I' || I === 0) continue;
+      const laws = this.constraints.filter((cs) => cs.terminals.includes(k));
+      if (laws.length === 0 && !this._chargeOnly(k)) continue;
+      const what = laws.flatMap((cs) => cs.parts.map(({ stretch }) => {
+        const st = this.stretches[stretch], [r0, r1] = st.regions;
+        return `${species[st.species].name} in ${regions[r0].name}${r1 > r0 ? `…${regions[r1].name}` : ''}`;
+      }));
+      this.charging = { terminal: this.terms[k].name, current: I, what };
+      return { converged: false, steps: 0, iterations: 0, history: [] };
     }
     const r = this._steadyFromHere(opts);
     this.atSteady = r.converged;
     return r;
   }
 
+  // Steady state from the present one, in three stages: Newton from here; failing that, from a
+  // solved state along the drives (the light ramped up, a current's terminal held at the voltages
+  // that pass it, the voltages ramped from where they were last solved); failing that, the
+  // pseudo-transient ramp, through time.
   _steadyFromHere(opts) {
     this.conditioning = null;
     this.computeConcentrations();
@@ -4373,86 +5007,110 @@ export class Solver {
     const [dl, dr] = [this.terms[0].drive, this.terms[1].drive];
     const held = (d) => d.kind === 'V' && !(d.R > 0);
     const target = sourceAt(dr.src, this.time), level = sourceAt(dl.src, this.time);
-    const canContinue = opts.continuation !== false && held(dl) && held(dr) && target !== level;
+    const allowed = opts.continuation !== false;
+    const canContinue = allowed && held(dl) && held(dr) && target !== level;
     const direct = this._directSteady();
     const u0 = Float64Array.from(this.u), u0Lo = Float64Array.from(this.uLo), v0 = Float64Array.from(this.termV);
-    // Where a direct solve applies and continuation is possible, don't spend long on the
-    // pseudo-transient ramp: one direct attempt first.
-    const quick = (canContinue || this.hasGeneration) && direct && opts.continuation !== false;
-    let r = this._solveSteady(quick ? { ...opts, maxSteps: 1 } : opts);
-    if (r.converged) this.solvedV = [level, target];
-    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) {
+    const restart = () => {
       this.u.set(u0);
       this.uLo.set(u0Lo);
       this.termV.set(v0);
       this.computeConcentrations();
+    };
+    const solved = (q) => {
+      if (q.converged) {
+        this.solvedV = [level, target];
+        this.stepped = false;
+      }
+      return q;
+    };
+    const after = (q, r) => ({ ...q, steps: q.steps + r.steps, iterations: q.iterations + r.iterations });
+
+    // 1. Newton from here. Where a continuation could follow, one direct attempt only, rather
+    // than the pseudo-transient ramp straight away.
+    const quick = (canContinue || this.hasGeneration) && direct && allowed;
+    let r = this._steadySteps(quick ? { ...opts, maxSteps: 1 } : opts);
+    if (r.converged) return solved(r);
+    // A transient's state can be a worse start than a cold one: 1 ns after a lit MOS capacitor's
+    // gate jumps, its surface is in deep depletion, minority carriers ten orders below where they
+    // end, and Newton fails from there where it converges from the layout for the drives (and
+    // the stages below took 9000 iterations from there, 2000 from the layout). What a steady
+    // solve keeps it took from the state already, so from here on it goes as a cold device would.
+    if (this.stepped && direct && allowed) {
+      this._refreshSources();
+      this.initFromComposition();
+      u0.set(this.u);
+      u0Lo.set(this.uLo);
+      const q = this._steadySteps(quick ? { ...opts, maxSteps: 1 } : opts);
+      if (q.converged) return solved(after(q, r));
+      restart();
+      r = after(q, r);
+    }
+
+    // 2. Continuation. 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 && allowed) {
+      restart();
       this.dimmer = false;
       const g = this._generationContinuation(opts, r);
       dimmer = this.dimmer;
-      if (g.converged) {
-        this.solvedV = [level, target];
-        return g;
-      }
+      if (g.converged) return solved(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();
+    if (allowed && this.floating.some((k) => this.terms[k].drive.kind === 'I' && !this._bound(k))) {
+      restart();
       const q = this._floatingContinuation(opts, r);
       if (q.converged) return q;
       r = q;
     }
-    if (!canContinue) {
-      if (quick) {
-        // 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);
-        return { ...full, steps: full.steps + r.steps, iterations: full.iterations + r.iterations };
-      }
-      return r;
-    }
-    // Source continuation: solve with both terminals level (consistent with a cold start), then
-    // ramp the right terminal's voltage to its target in adaptive steps.
-    const restart = () => {
-      this.u.set(u0);
-      this.uLo.set(u0Lo);
-      this.termV.set(v0);
-      this.computeConcentrations();
-    };
-    restart();
-    // Ramp from the contacts' voltages at the last converged solve when the state is that
-    // solution (a warm start): the left one first where it moved, the right held where it was,
-    // then the right. Otherwise from level terminals.
-    const solved = this.solvedV;
-    let c;
-    if (solved) {
-      c = solved[0] === level ? { ...r, converged: true, ramped: false } : this._continuation(opts, 0, solved[0], level, r, true, solved[1]);
-      // (Ramping the right from level terminals, solve there first: a sweep's start.)
-      if (c.converged) c = this._continuation(opts, 1, solved[1], target, c, c.ramped || solved[1] !== level);
-    } else c = this._continuation(opts, 1, level, target, r, false);
-    if (c.converged) {
-      this.solvedV = [level, target];
-      return c;
-    }
-    restart();
-    r = this._solveSteady(opts); // the full pseudo-transient ramp
-    if (r.converged) this.solvedV = [level, target];
-    return { ...r, steps: r.steps + c.steps, iterations: r.iterations + c.iterations };
+    if (canContinue) {
+      // The right terminal's voltage ramped to its target: from the contacts' voltages at the last
+      // converged solve when the state is that solution (a warm start), the left one first where
+      // it moved, the right held where it was; otherwise from level terminals, consistent with a
+      // cold start.
+      restart();
+      const was = this.solvedV;
+      let c;
+      if (was) {
+        c = was[0] === level ? { ...r, converged: true, ramped: false } : this._continuation(opts, 0, was[0], level, r, true, was[1]);
+        // (Ramping the right from level terminals, solve there first: a sweep's start.)
+        if (c.converged) c = this._continuation(opts, 1, was[1], target, c, c.ramped || was[1] !== level);
+      } else c = this._continuation(opts, 1, level, target, r, false);
+      if (c.converged) return solved(c);
+      // 3. The pseudo-transient ramp, from the start.
+      restart();
+      return solved(after(this._steadySteps(opts), c));
+    }
+    // 3. The pseudo-transient ramp (where the first attempt wasn't it already): 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 (!quick) return r;
+    if (!dimmer) restart();
+    else this.computeConcentrations();
+    return after(this._steadySteps(opts), r);
+  }
+
+  // Whether terminal k, driven by a current, feeds a combination that it alone can change, or
+  // only charges a capacitance (so that its steady states are one per amount or charge, not one
+  // per voltage).
+  _bound(k) {
+    return this.constraints.some((cs) => cs.terminals.includes(k)) || this._chargeOnly(k);
+  }
+
+  // Whether terminal k passes current only by charging a capacitance: no charged species through
+  // it (nor, a port, reactions), and a capacitance to charge (a gate's φ law, a port's own).
+  _chargeOnly(k) {
+    const t = this.terms[k], { species } = this.model;
+    const ions = (links) => links.some((l, i) => l.type !== 'blocked' && species[i].z !== 0);
+    if (t.kind === 'port') {
+      const p = this.model.ports[t.index];
+      return p.reactions.length === 0 && !ions(p.species) && !!p.capacitance;
+    }
+    const c = this.model.contacts[t.side];
+    return !ions(c.species) && (c.phi.type === 'capacitive' || c.phi.type === 'pinned');
   }
 
   // A cold steady solve with a terminal driven by a current, which can fail where the same state
@@ -4461,7 +5119,7 @@ export class Solver {
   // 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 k = this.floating.find((j) => this.terms[j].drive.kind === 'I' && !this._bound(j));
     const drive = this.terms[k].drive, target = sourceAt(drive.src, this.time);
     let steps = r.steps ?? 0, iterations = r.iterations ?? 0;
     const history = (r.history ?? []).slice();
@@ -4524,7 +5182,7 @@ export class Solver {
       this.terms[k].drive = drive;
       this.redrive();
     }
-    const q = this._solveSteady(opts);
+    const q = this._steadySteps(opts);
     steps += q.steps ?? 0;
     iterations += q.iterations ?? 0;
     history.push(...(q.history ?? []));
@@ -4567,7 +5225,7 @@ export class Solver {
     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);
+      let q = this._steadySteps(sub);
       steps += q.steps;
       iterations += q.iterations;
       if (!q.converged) return { converged: false, steps, iterations, history };
@@ -4576,7 +5234,7 @@ export class Solver {
         const next = Math.min(1, s * factor);
         const u1 = Float64Array.from(this.u), u1Lo = Float64Array.from(this.uLo), v1 = Float64Array.from(this.termV);
         this.generationScale = next;
-        q = this._solveSteady(sub);
+        q = this._steadySteps(sub);
         steps += q.steps;
         iterations += q.iterations;
         history.push({ generation: next, converged: q.converged });
@@ -4612,7 +5270,7 @@ export class Solver {
       if (hold !== undefined) this.sourceOverride.set(1 - k, hold);
       let q;
       if (!warm) {
-        q = this._solveSteady(opts);
+        q = this._steadySteps(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.
@@ -4620,7 +5278,7 @@ export class Solver {
           iterations += q.iterations;
           this._refreshSources();
           this.initFromComposition();
-          q = this._solveSteady(opts);
+          q = this._steadySteps(opts);
         }
         // (lit, the level start may need the light ramped up too)
         if (!q.converged && this.hasGeneration) q = this._generationContinuation(opts, q);
@@ -4632,7 +5290,7 @@ export class Solver {
         const next = Math.abs(target - V) <= Math.abs(dV) ? target : V + dV;
         const u1 = Float64Array.from(this.u), u1Lo = Float64Array.from(this.uLo), v1 = Float64Array.from(this.termV);
         this.sourceOverride.set(k, next);
-        q = this._solveSteady(sub);
+        q = this._steadySteps(sub);
         steps += q.steps;
         iterations += q.iterations;
         history.push({ continuation: next, converged: q.converged });
@@ -4656,23 +5314,11 @@ export class Solver {
     }
   }
 
-  _solveSteady(opts = {}) {
-    this.constrained = true; // spectators' amounts as constraints in the dt = ∞ solves
-    this.steady = true;
-    try {
-      return this._steadySteps(opts);
-    } finally {
-      this.constrained = false;
-      this.steady = false;
-    }
-  }
-
   _steadySteps({ maxSteps = 80, tol = 1e-11 } = {}) {
     const time = this.time;
     const tau = this.slowestTime();
     const direct = this._directSteady();
     const giant = direct ? Infinity : 1e6 * tau;
-    if (direct) this._renormalizeSpectators(); // a starting point with the right amounts
     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;