driftlet 0.13.0 → 0.16.2

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.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}`).join();
+    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,84 @@ 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)
+    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 +947,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));
     for (const st of this.stretches) {
       const i = st.species, [s0, s1] = st.regions;
       if (!st.mobile || conductor(st)) continue;
@@ -870,19 +996,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 +1067,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,28 +1128,47 @@ 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;
+  // 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 = []) {
+    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;
     const rows = [];
     model.interfaces.forEach((itf, f) => {
       for (const rx of itf.reactions) {
@@ -992,6 +1186,7 @@ export class Solver {
         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);
       }
@@ -1005,16 +1200,32 @@ export class Solver {
         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,6 +1251,7 @@ 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);
     }
     return basis;
@@ -1056,39 +1268,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 +1288,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 +1422,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,9 +1503,13 @@ 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.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}`).join();
+    if (this.drivenKey !== driven) this._laws();
     this._refreshSources();
     this.history = [];
   }
@@ -1355,11 +1668,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 +1721,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 +1994,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 +2026,15 @@ 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.constraints.length > 0) this._applyConstraints();
+    if (steady && this.localConstraints.length > 0) this._applyLocalConstraints();
+    this.pinnedIslands = steady && this.islandsOn ? this._applyIslands() : [];
+    this.pins = steady ? [...this.constraints.filter((cs) => cs.circuit < 0), ...this.pinnedIslands] : [];
     this.transformed = this.combining && dt !== Infinity;
     if (this.transformed) this._chargeRows(dt);
   }
@@ -2347,6 +2692,21 @@ export class Solver {
     return P * -Math.expm1(-(aHi + aLo));
   }
 
+  // A bulk reaction's forward one-way rate at node g (mol/(m³·s)); its backward one is that
+  // times e^{−a}, so their difference is bulkRate's.
+  bulkForward(rx, g) {
+    const { n, M, u, uLo, c } = this, b = this.blockOfNode[g];
+    const law = rx.srh?.[this.nodeMaterial[g]];
+    if (law) {
+      let a = rx.fixedA;
+      for (let p = 0; p < rx.sp.length; p++) a += rx.nu[p] * (u[b * M + 1 + rx.sp[p]] + uLo[b * M + 1 + rx.sp[p]]);
+      return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], a).forward;
+    }
+    let P = rx.generation ? rx.kfNode[g] * this.generationScale : rx.kfNode[g];
+    for (let p = 0; p < rx.sp.length; p++) if (rx.nu[p] > 0) P *= rx.nu[p] === 1 ? c[g * n + rx.sp[p]] : powi(c[g * n + rx.sp[p]], rx.nu[p]);
+    return P;
+  }
+
   // The larger of a bulk reaction's two one-way rates at node g (mol/(m³·s)): the scale its net
   // rate is read against (in equilibrium the net rate is their round-off).
   bulkOneWay(rx, g) {
@@ -2376,7 +2736,7 @@ export class Solver {
     const dDn = tp * cn + tp * n1 * kN + tn * p1 * (1 - kN);
     const dDp = tp * n1 * kP + tn * cp + tn * p1 * (1 - kP);
     const dDa = tp * n1 * kA + tn * p1 * (-1 - kA);
-    return { rate, oneWay: (np / den) * Math.max(1, Math.exp(-a)), Cn: rate * (1 - dDn / den), Cp: rate * (1 - dDp / den), Ca: (np / den) * (1 - f) - (rate * dDa) / den };
+    return { rate, forward: np / den, oneWay: (np / den) * Math.max(1, Math.exp(-a)), Cn: rate * (1 - dDn / den), Cp: rate * (1 - dDp / den), Ca: (np / den) * (1 - f) - (rate * dDa) / den };
   }
 
   // A face reaction (see normalizeFaceReactions). Its rate r_k is an unknown of the face block,
@@ -2521,7 +2881,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);
@@ -2663,6 +3024,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;
@@ -2675,12 +3039,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;
     }
   }
 
@@ -2801,10 +3165,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.
@@ -2813,6 +3180,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') {
@@ -2845,12 +3215,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;
@@ -2858,7 +3258,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.
@@ -2875,23 +3275,6 @@ 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]);
-      }
-    }
-  }
   _replaceRow(b, rs) {
     const l = this.loc[b * this.M + rs];
     if (l < 0) return;
@@ -2979,6 +3362,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];
@@ -3078,7 +3466,7 @@ export class Solver {
     this.islandsOn = islands;
     let rounds = 0, kept = null;
     const islandsOff = (it, result) => {
-      if (dt !== Infinity || !this.constrained || this.islands.length === 0 || rounds >= 2 || !(this._kirchhoff() > 1e-9)) return false;
+      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) };
@@ -3152,7 +3540,13 @@ export class Solver {
       const alpha = own > maxStep ? maxStep / own : 1;
       this._addToState(delta, -alpha);
       this.floating.forEach((k, a) => (this.termV[k] -= alpha * deltaV[a]));
-      if (alpha === 1 && step < tol) {
+      // A time step's Newton contracts fast from its predictor (1e-2, 1e-9, 1e-15 thermal
+      // units). The next update would be about θ = step/(the last one) times this one, so where
+      // θ/(1 − θ) of it (Hairer and Wanner's estimate) is under tol, this update converged it:
+      // the iteration that would only show that is skipped, a third of a typical step's work.
+      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)) {
         const done = { converged: true, iterations: it, history, residual: rmax };
         if (islandsOff(it, done)) continue;
         this.computeConcentrations();
@@ -3206,18 +3600,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 };
   }
 
   /**
@@ -3307,13 +3703,14 @@ 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).
@@ -3327,6 +3724,20 @@ export class Solver {
         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.u.set(opts.guess);
+          this.uLo.fill(0);
+        }
+        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;
     }
@@ -3339,11 +3750,16 @@ 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;
@@ -3358,6 +3774,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();
@@ -3562,9 +3983,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;
@@ -3718,6 +4148,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();
@@ -4120,6 +4559,72 @@ export class Solver {
     return cuts;
   }
 
+  // Each species' flux toward +x across every segment, at the current state (concentrations
+  // computed): totals through the cross-section, mol/s (mol/(m²·s) for a planar device). A face's
+  // segment, between its pair of nodes, carries the face's flux; a conductor's, its carrier's.
+  // These are the fluxes the balances add up (displacement aside), from the same formulas.
+  segmentFluxes() {
+    const { model, n, M, u, uLo, c, z, ex } = this;
+    const { grid, materials, regions, interfaces } = model;
+    const out = Array.from({ length: n }, () => new Float64Array(grid.nNodes - 1));
+    for (let r = 0; r < regions.length; r++) {
+      const reg = regions[r], mat = materials[reg.material], vel = reg.velocity;
+      for (let s = grid.regionStart[r]; s < grid.regionEnd[r]; s++) {
+        const bL = s + r, bR = bL + 1, h = grid.segLength[s] / grid.segArea[s];
+        if (mat.conductor) {
+          out[mat.conductor.i][s] = u[bL * M];
+          continue;
+        }
+        for (let i = 0; i < n; i++) {
+          if (!mat.present[i] || mat.D[i] === 0) continue;
+          const pe = (vel * h) / mat.D[i];
+          const d = z[i] * (u[bR * M] - u[bL * M]) + ex[(s + 1) * n + i] - ex[s * n + i] - pe;
+          const deta = u[bR * M + 1 + i] - u[bL * M + 1 + i] + (uLo[bR * M + 1 + i] - uLo[bL * M + 1 + i]) - pe;
+          out[i][s] = -(mat.D[i] / h) * bernoulli(d) * c[s * n + i] * Math.expm1(deta);
+        }
+        if (reg.mixing > 0) {
+          // Eddy mixing (see _segmentMixing): −(D_mix/h) c̄_i (Δη_i − z_i q), c̄ the logarithmic mean.
+          const on = [...Array(n).keys()].filter((i) => mat.present[i] && mat.D[i] > 0);
+          const cb = [], de = [];
+          let S = 0, Q = 0;
+          for (const k of on) {
+            const a = c[s * n + k], b = c[(s + 1) * n + k];
+            cb[k] = a === b ? a : (b - a) / Math.log(b / a);
+            de[k] = u[bR * M + 1 + k] - u[bL * M + 1 + k] + (uLo[bR * M + 1 + k] - uLo[bL * M + 1 + k]);
+            S += z[k] * z[k] * cb[k];
+            Q += z[k] * cb[k] * de[k];
+          }
+          const q = S > 0 ? Q / S : 0;
+          for (const i of on) out[i][s] -= (reg.mixing / h) * cb[i] * (de[i] - z[i] * q);
+        }
+      }
+    }
+    interfaces.forEach((itf, f) => {
+      const gL = grid.regionEnd[f], b = this.blockOfFace[f];
+      for (let i = 0; i < n; i++) if (itf.links[i].type !== 'blocked') out[i][gL] = grid.area[gL] * u[b * M + 1 + i];
+    });
+    return out;
+  }
+
+  // A face's one-way fluxes for each species crossing it by permeability, per area: toward +x
+  // and toward −x, whose difference is its net flux (Ussing's unidirectional fluxes; GHK's two
+  // terms between like solutions). null for a species crossing any other way.
+  faceOneWay(f) {
+    const { model, n, M, u, uLo, z } = this, itf = model.interfaces[f], grid = model.grid;
+    const bL = this.blockOfFace[f] - 1, bR = bL + 2, gl = grid.regionEnd[f], gr = gl + 1;
+    return itf.links.map((link, i) => {
+      if (link.type !== 'permeability') return null;
+      const kl = gl * n + i, kr = gr * n + i;
+      const shift = this.mu0hat[kr] - this.mu0hat[kl] - Math.log(this.cRef[kr] / this.cRef[kl]);
+      const d = z[i] * (u[bR * M] - u[bL * M] + (uLo[bR * M] - uLo[bL * M])) + shift;
+      const deta = u[bR * M + 1 + i] - u[bL * M + 1 + i] + (uLo[bR * M + 1 + i] - uLo[bL * M + 1 + i]);
+      const gated = link.gates ?? [];
+      const P = link.P * (gated.length ? this._open(gated, (q) => u[this._gateSlot(f, q)]) : 1);
+      const right = P * bernoulli(d) * this.c[kl];
+      return [right, right * Math.exp(deta)];
+    });
+  }
+
   // Complex profiles of δφ (V), δμ̄ (J/mol) and δc (mol/m³) from a small-signal solution.
   _smallSignalProfiles(xr, xi) {
     const { n, M, z, VT, model } = this;
@@ -4203,12 +4708,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;
@@ -4238,45 +4751,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();
@@ -4286,86 +4809,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
@@ -4374,7 +4921,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();
@@ -4437,7 +4984,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 ?? []));
@@ -4480,7 +5027,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 };
@@ -4489,7 +5036,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 });
@@ -4525,7 +5072,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.
@@ -4533,7 +5080,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);
@@ -4545,7 +5092,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 });
@@ -4569,23 +5116,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;