driftlet 1.1.1 → 1.2.2

package/src/solver.js

@@ -220,6 +220,8 @@ import { EPS0, FARADAY } from './constants.js';
 import { nextBreakpoint, sourceAt } from './device.js';
 import { DifferenceTerms } from './difference.js';
 import { DeviceError } from './errors.js';
+import { chargeOnly, conservedMoieties, feeds, findLaws, noCurrent } from './laws.js';
+import { applyLaws, captureLaws, captureLocal, snapFlat, solveBordered } from './lawRows.js';
 import { powi, powr } from './pow.js';
 
 // A profile's value at x (c0, kf): piecewise linear, constant beyond its ends.
@@ -482,7 +484,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)
+    this.lawForm = new Map(); // (each circuit law: read as its change this step, see src/lawRows.js)
     // 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.
@@ -493,16 +495,20 @@ export class Solver {
     this.sourceTime = 0;
     this.sourceOverride = new Map(); // terminal → voltage, while a steady solve ramps it
     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).
+    // The floating ones are extra unknowns, solved with the grid's by bordering (solveBordered in
+    // src/lawRows.js).
     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.lawRefs = new Map(); // what a steady solve keeps behind a terminal at no current (src/lawRows.js)
     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));
     this.termC = this.terms.map(() => new Float64Array(this.sys.size + 1));
     this.termDI = new Float64Array(this.terms.length);
+    // (and a circuit row's derivatives by other terminals' voltages: a law in one's row that counts
+    // another electrode's charge)
+    this.termDX = this.terms.map(() => new Float64Array(this.terms.length));
     this.termRes = new Float64Array(this.terms.length);
     this._refreshSources();
     // A floating terminal starts level with the first held one (no current).
@@ -733,7 +739,8 @@ export class Solver {
     // a port). So Ag⁺ between silver electrodes is fed (Ag⁺ + e⁻ ⇌ Ag(s), the electrons fed by the
     // contacts), while Fe³⁺ and Fe²⁺ between platinum electrodes aren't (Fe³⁺ + e⁻ ⇌ Fe²⁺
     // conserves the iron, whatever the electrons do).
-    this.moieties = this._conservedMoieties();
+    this.rough = this.stretches.map((st) => this._roughAmount(st));
+    this.moieties = conservedMoieties(this._structure());
     this.stretches.forEach((st, k) => {
       st.connected = st.contactFed || this.moieties.every((w) => w[k] === 0);
     });
@@ -750,7 +757,8 @@ export class Solver {
     // 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.
+    // flat (flatRows in src/lawRows.js): 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) => {
@@ -783,7 +791,7 @@ export class Solver {
         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)]);
+        rxns.push([ks, (side) => rx.part.reduce((a, p) => a - p.nu * this.contactEta(side, p.i), rx.fixedA)]); // (a face's ν: products +, so − Σ ν η)
       }
     });
     const groups = new Map();
@@ -814,776 +822,39 @@ export class Solver {
     return t;
   }
 
-  // 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.
+  // The laws a steady solve keeps (src/laws.js finds them, from the structure alone), set on the
+  // solver with the state that goes with them; again after a change of drive.
   _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 (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;
-    // 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,
-        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,
-        res: 0,
-        q: new Float64Array(this.sys.size + 1),
-      });
-    };
-    this.stretches.forEach((st, 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, 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 && 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._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 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((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
-    // contact, port or reaction) holds its level only through its faces' fluxes, which can be
-    // ~1e-24 of its own conduction (a tiny conductance at the face, or a neighbour that barely
-    // conducts): eliminated, the level is lost to round-off, and Newton settles at a wrong one with
-    // nothing to show for it. In steady solves the piece's balance summed over its nodes, where
-    // the internal fluxes cancel exactly and the faces' alone are left, replaces its first node's
-    // (see _applyIslands), once the plain solves converge (see newton).
-    this.islands = [];
+    const found = findLaws(this._structure());
+    for (const [k, st] of this.stretches.entries()) st.conserved = found.conserved.has(k);
+    this.constraints = found.constraints;
+    this.affinities = found.affinities;
+    this.localConstraints = found.localConstraints;
+    this.islands = found.islands;
+    this.timeLaws = found.timeLaws;
+    this.contactLaw = found.contactLaw;
+    this.carriers = found.carriers;
+    this.unkept = found.unkept; // (laws no row here can keep: see _directSteady)
+    this.contactQ = [null, null]; // (each contact's charge as _contact captures it, for contactLaw)
     this.pinnedIslands = [];
     this.islandsOn = false; // (newton() turns them on, see there)
     this.pins = [];
-    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;
-      for (let q0 = s0, q1 = s0; q1 <= s1; q1++) {
-        const p0 = q0;
-        q0 = q1 + 1;
-        if (p0 === s0 && q1 === s1) continue; // (uncut)
-        if ((p0 === s0 && st.leftOpen) || (q1 === s1 && st.rightOpen)) continue;
-        const inside = (q) => q >= p0 && q <= q1;
-        if (model.ports.some((port) => inside(port.region) && (port.species[i].type !== 'blocked' || port.reactions.some((rx) => rx.part.some((p) => p.side === 0 && p.i === i))))) continue;
-        let reactive = false;
-        for (let q = p0; q <= q1; q++) {
-          for (const rx of model.reactions) if (rx.kf[regions[q].material] > 0 && [...rx.reactants, ...rx.products].some((p) => p.i === i)) reactive = true;
-        }
-        for (let f = Math.max(0, p0 - 1); f <= Math.min(model.interfaces.length - 1, q1); f++) {
-          for (const rx of model.interfaces[f].reactions) if (rx.part.some((p) => p.i === i && inside(f + p.side))) reactive = true;
-        }
-        const row = this.blockOfNode[grid.regionStart[p0]] * this.M + 1 + i;
-        if (reactive || used.has(row)) continue;
-        used.add(row);
-        // The faces' fluxes into the piece: −A_f u at its left face, +A_f u at its right. Across
-        // a face that holds μ̄ level, u is set only by the edge balances, and eliminated, it can
-        // come out of the piece's own (G Δη, its two η all but equal: a neighbour 1e20 times
-        // less conductive, and the piece's level was seen through one face of two, and Newton
-        // swung it back and forth across both). There the outside edge node's balance is added:
-        // u cancels, and the outside's first segment carries the flux instead.
-        const faces = [], outside = [];
-        if (p0 > s0) faces.push([p0 - 1, -1, grid.regionEnd[p0 - 1]]);
-        if (q1 < s1) faces.push([q1, 1, grid.regionStart[q1 + 1]]);
-        for (const [f, , g] of faces) {
-          if (model.interfaces[f].links[i].type !== 'equilibrium' || g === 0 || g === this.nNodes - 1) continue;
-          if (model.ports.some((port) => port.nodes.includes(g))) continue;
-          outside.push(this.blockOfNode[g] * this.M + 1 + i);
-        }
-        this.islands.push({
-          stretch: st,
-          row,
-          flux: faces.map(([f]) => this.blockOfFace[f] * this.M + 1 + i),
-          weight: faces.map(([f, sg]) => sg * grid.area[grid.regionEnd[f]]),
-          outside,
-          idx: new Int32Array(faces.length + 3 * this.M * outside.length),
-          w: new Float64Array(faces.length + 3 * this.M * outside.length),
-          len: 0,
-          res: 0,
-        });
-      }
-    }
-    for (const isl of this.islands) isl.outside = isl.outside.filter((o) => !used.has(o));
-
-    // 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, th, nSurf } = this;
-    for (const lc of this.localConstraints) {
-      lc.nodes.forEach((g, j) => {
-        let t = 0;
-        for (const { i, q, w } of lc.parts) t += w * (i !== undefined ? c[g * n + i] : th[g * nSurf + q]);
-        lc.reference[j] = t;
-      });
-    }
-  }
-
-  // The islands' summed balances (steady solves only): Σ A_f u over the faces into each, its
-  // first node's row pinned in the factorised matrix and the sum bordered (_solveBordered) like a
-  // conserved amount's. The pieces of a stretch held flat by its contact are left as they are.
-  _applyIslands() {
-    const { u, res } = this, R = this.rix, out = [];
-    for (const isl of this.islands) {
-      if (this.flatStretches.includes(isl.stretch)) continue;
-      const b0 = Math.floor(isl.row / this.M), r0 = isl.row % this.M;
-      if (this.loc[isl.row] < 0) continue;
-      // Gathered by column (the faces' u, then each outside row's entries, which cancel those u
-      // exactly where they meet), then the nonzeros kept.
-      const acc = this.islandRow ?? (this.islandRow = new Float64Array(this.sys.size + 1));
-      const cols = [];
-      const add = (col, v) => {
-        if (acc[col] === 0) cols.push(col);
-        acc[col] += v;
-      };
-      let t = 0;
-      isl.flux.forEach((o, j) => {
-        if (this.loc[o] < 0) return;
-        t += isl.weight[j] * u[o];
-        add(R[o], isl.weight[j]);
-      });
-      for (const o of isl.outside) {
-        if (this.loc[o] < 0) continue;
-        t += res[R[o]];
-        this._rowInto(o, add);
-      }
-      let len = 0;
-      for (const col of cols) {
-        if (col < this.sys.size && acc[col] !== 0) {
-          isl.idx[len] = col;
-          isl.w[len++] = acc[col];
-        }
-        acc[col] = 0;
-      }
-      isl.len = len;
-      isl.res = t;
-      this._replaceRow(b0, r0);
-      for (const B of this.termB) B[R[isl.row]] = 0;
-      this._j(b0, r0, b0, r0, 1);
-      res[R[isl.row]] = 0;
-      out.push(isl);
-    }
-    return out;
   }
 
-  // Row o's Jacobian entries, as add(compact column, value): the assembled ones, and the dilute
-  // kernels' kept aside in difference form (see _assembleDifference) when they are.
-  _rowInto(o, add) {
-    const { sys, M, nB } = this, b = Math.floor(o / M), l = this.loc[o];
-    const { A, B, C, sizes, offA, offB, offC, offX } = sys, m = sizes[b];
-    for (let k = 0; k < m; k++) if (B[offB[b] + l * m + k] !== 0) add(offX[b] + k, B[offB[b] + l * m + k]);
-    if (b > 0) for (let k = 0, mp = sizes[b - 1]; k < mp; k++) if (A[offA[b] + l * mp + k] !== 0) add(offX[b - 1] + k, A[offA[b] + l * mp + k]);
-    if (b < nB - 1) for (let k = 0, mn = sizes[b + 1]; k < mn; k++) if (C[offC[b] + l * mn + k] !== 0) add(offX[b + 1] + k, C[offC[b] + l * mn + k]);
-    if (this.lin) {
-      const into = this.linRow ?? (this.linRow = new Float64Array(sys.size + 1));
-      this.lin.capture(this.rix[o], 1, 0, into);
-      for (let k = 0; k < sys.size; k++) {
-        if (into[k] !== 0) add(k, into[k]);
-        into[k] = 0;
-      }
-    }
-  }
-
-  // The local constraints' rows (steady solves only): Σ w c_i − reference at each node.
-  _applyLocalConstraints() {
-    const { n, M, c, th, nSurf, res, dA: d } = this;
-    for (const lc of this.localConstraints) {
-      lc.nodes.forEach((g, j) => {
-        const b = this.blockOfNode[g];
-        if (this.loc[b * M + lc.row] < 0) return;
-        this._replaceRow(b, lc.row);
-        let t = 0;
-        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[j];
-      });
-    }
+  // What src/laws.js reads (see its contract): the device's structure, never the state.
+  _structure() {
+    const { model, n, M, z, nNodes, stretches, stretchOf, flatStretches, rough, surfCols, surfColOf, terms, floating } = this;
+    const { blockOfNode, blockOfFace, rxsIn, nodeMaterial, phiUndefined } = this;
+    return { model, n, M, z, nNodes, stretches, stretchOf, flatStretches, rough, surfCols, surfColOf, terms, floating, blockOfNode, blockOfFace, rxsIn, nodeMaterial, phiUndefined };
   }
 
-  // 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 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;
-        (rx === skip ? skipped : rows).push(row);
-      }
-    });
-    // An electrode surface's species are columns too, after the stretches (S + j for surface
-    // column j), so a combination that passes through them (A⁺ + e⁻ = S, S + e⁻ = B⁻) is conserved
-    // with what the surface holds.
-    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;
-        }
-        if (rx !== skip) rows.push(row);
-      }
-    });
-    model.regions.forEach((reg, q) => {
-      for (const rx of model.reactions) {
-        if (!(rx.kf[reg.material] > 0)) continue;
-        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;
-        (rx === skip ? skipped : rows).push(row);
-      }
-    });
-    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. 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).
-    // Then the stretches by their starting amounts, least first, and by name: a trace species
-    // pivoted after an abundant one comes out added to it (A + B ⇌ C with B at 1 M and A at 1e-14
-    // gave B + C and A − B, where A + C was lost to round-off), and the basis followed the listing.
-    const still = (k) => (k < S && this._still(this.stretches[k]) ? 1 : 0);
-    const rough = this.stretches.map((st) => this._roughAmount(st)), name = (k) => model.species[this.stretches[k].species].name;
-    const order = [...Array(C).keys()].sort((a, b) => {
-      if (still(a) !== still(b)) return still(b) - still(a);
-      if (a >= S || b >= S) return a - b;
-      if (rough[a] !== rough[b]) return rough[a] - rough[b];
-      const na = name(a), nb = name(b);
-      return na < nb ? -1 : na > nb ? 1 : a - b;
-    });
-    const pivots = [];
-    let r = 0;
-    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;
-      [rows[r], rows[best]] = [rows[best], rows[r]];
-      const pr = rows[r], pv = pr[col];
-      for (let j = 0; j < C; j++) pr[j] /= pv;
-      for (let i = 0; i < rows.length; i++) {
-        if (i === r || rows[i][col] === 0) continue;
-        const fct = rows[i][col];
-        for (let j = 0; j < C; j++) rows[i][j] -= fct * pr[j];
-      }
-      pivots.push(col);
-      r++;
-    }
-    const isPivot = new Uint8Array(C);
-    for (const col of pivots) isPivot[col] = 1;
-    const basis = [];
-    for (let free = 0; free < C; free++) {
-      if (isPivot[free]) continue;
-      const w = new Float64Array(C);
-      w[free] = 1;
-      pivots.forEach((col, i) => {
-        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;
-  }
-
-  // Every stretch either reaches a contact or is a mobile spectator: the steady equations can
-  // be solved directly (dt = ∞), with the spectators' amounts as constraints.
+  // Every stretch either reaches a contact or is kept by a law, and no law is left unkept: the
+  // steady equations can be solved directly (dt = ∞), with the laws in place of their rows. Else
+  // the steady solve goes by time steps, which keep every amount themselves.
   _directSteady() {
-    return this.stretches.every((st) => st.connected || st.conserved);
-  }
-
-  // Conservation rows for the spectators (steady solves only): Σ v c_i = amount over the
-  // stretch replaces the balance row of its first node, which in steady state is the negative
-  // 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 { M, res } = this;
-    for (const cs of this.constraints) {
-      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;
-      }
-      const b0 = Math.floor(cs.row / M), r0 = cs.row % M;
-      this._replaceRow(b0, r0);
-      this._j(b0, r0, b0, r0, 1);
-      res[this.rix[cs.row]] = 0;
-    }
-  }
-
-  // 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 };
+    return this.unkept.length === 0 && this.stretches.every((st) => st.connected || st.conserved);
   }
 
-  // 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
-  // islands' summed balances (see _applyIslands). By low-rank
-  // updates of T (Woodbury): δ = y + Σ_q Q_q μ_q − Σ_k X_k δV_k with y = T⁻¹ rhs, Q_q = T⁻¹ e_q
-  // (the response to a unit pin) and X_k = T⁻¹ B_k (to a unit change of V_k), then a small dense
-  // system for the μ (pins) and δV (terminals):
-  //   pin q:      Σ (W_q·Q_q′) μ_q′ − Σ (W_q·X_k) δV_k = res_q − W_q·y
-  //   terminal k: Σ (C_k·Q_q) μ_q + Σ (δ_kk′ ∂I_k/∂V_k − C_k·X_k′) δV_k′ = res_k − C_k·y
-  _solveBordered(rhs, delta, deltaV, pins) {
-    const N = this.sys.size, fl = this.floating, P = pins.length, K = fl.length, S = P + K;
-    this._solveLinear(rhs, delta);
-    if (S === 0) return;
-    const e = this.dWork ?? (this.dWork = new Float64Array(N + 1));
-    const cols = this.borderCols ?? (this.borderCols = []);
-    for (let a = 0; a < S; a++) {
-      if (!cols[a]) cols[a] = new Float64Array(N + 1);
-      if (a < P) {
-        // 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]);
-        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).
-    const dot = (a, v) => {
-      let t = 0;
-      if (a < P) {
-        const p = pins[a];
-        for (let j = 0; j < p.len; j++) t += p.w[j] * v[p.idx[j]];
-      } else {
-        const C = this.termC[fl[a - P]];
-        for (let j = 0; j < N; j++) t += C[j] * v[j];
-      }
-      return t;
-    };
-    const A = Array.from({ length: S }, () => new Float64Array(S + 1));
-    for (let a = 0; a < S; a++) {
-      for (let b = 0; b < S; b++) A[a][b] = (b < P ? 1 : -1) * dot(a, cols[b]);
-      if (a >= P) A[a][a] += this.termDI[fl[a - P]];
-      A[a][S] = (a < P ? pins[a].res : this.termRes[fl[a - P]]) - dot(a, delta);
-      let mx = 0;
-      for (let b = 0; b < S; b++) mx = Math.max(mx, Math.abs(A[a][b]));
-      if (mx > 0) for (let b = 0; b <= S; b++) A[a][b] /= mx;
-    }
-    // Small dense solve with partial pivoting.
-    for (let col = 0; col < S; col++) {
-      let p = col;
-      for (let r = col + 1; r < S; r++) if (Math.abs(A[r][col]) > Math.abs(A[p][col])) p = r;
-      [A[col], A[p]] = [A[p], A[col]];
-      if (A[col][col] === 0) throw new SolverError('the bordered system is singular: a conserved amount or a floating terminal is not determined');
-      for (let r = col + 1; r < S; r++) {
-        const f = A[r][col] / A[col][col];
-        for (let k = col; k <= S; k++) A[r][k] -= f * A[col][k];
-      }
-    }
-    const x = new Float64Array(S);
-    for (let r = S - 1; r >= 0; r--) {
-      let v = A[r][S];
-      for (let k = r + 1; k < S; k++) v -= A[r][k] * x[k];
-      x[r] = v / A[r][r];
-    }
-    for (let a = 0; a < S; a++) {
-      const sa = a < P ? x[a] : -x[a], col = cols[a];
-      for (let j = 0; j < N; j++) delta[j] += sa * col[j];
-      if (a >= P) deltaV[a - P] = x[a];
-    }
-  }
-
-
   // An electrode surface at its starting coverages at node g: η = μ°/RT + ln(θ/θ₀).
   _surfaceStart(g) {
     const { n, M, u, model } = this, surf = model.ports[this.surfPort[g]].surface, b = this.blockOfNode[g];
@@ -1616,7 +887,7 @@ export class Solver {
     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)
+    // (and one put behind a resistance, or taken from it, its time steps' reading: see src/laws.js)
     this.drivenKey = this._drivenKey();
     if (this.drivenKey !== driven) this._laws();
     this._refreshSources();
@@ -1624,17 +895,17 @@ export class Solver {
   }
 
   // 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
+  // (see src/laws.js), 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 passes = (k) => !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) && feeds(j, this.stretches[k])))));
     const needed = (rx) => {
-      const basis = this._conservedMoieties(true, [], rx);
+      const basis = conservedMoieties(this._structure(), { drives: true, skip: 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];
@@ -1667,15 +938,11 @@ export class Solver {
     return out;
   }
 
-  // How each terminal is driven, as far as the laws care (see _laws): by a voltage or a current,
+  // How each terminal is driven, as far as the laws care (see src/laws.js): 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;
+    return this.terms.map((t) => `${t.drive.kind}${t.drive.R > 0 ? 'R' : ''}${noCurrent(t) ? '0' : ''}`).join();
   }
 
   // Held terminals take their sources' values at sourceTime (a floating one keeps its voltage,
@@ -2182,7 +1449,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();
+    if (this.steady && dt === Infinity) snapFlat(this);
     this.computeConcentrations();
 
     // Regions, each assembled by the kernel for its kind: a conductor (its carrier only), a
@@ -2214,16 +1481,9 @@ 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 (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] : [];
+    // The laws' rows (src/lawRows.js): a time step's circuit laws; a steady system's levels held
+    // flat, affinities, conserved amounts, islands' balances, and the pins held aside of them.
+    applyLaws(this, dt);
     this.transformed = this.combining && dt !== Infinity;
     if (this.transformed) this._chargeRows(dt);
   }
@@ -3082,6 +2342,7 @@ export class Solver {
       this.termC[k].fill(0);
     }
     this.termDI.fill(0);
+    for (const x of this.termDX) x.fill(0);
     this.termI.fill(0);
     this.qg.fill(0);
     this.qgSlope.fill(0);
@@ -3281,7 +2542,7 @@ export class Solver {
     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).
+    // charge it keeps in place of that (see captureLaws in src/lawRows.js).
     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) => {
@@ -3413,6 +2674,14 @@ export class Solver {
     // φ law (none where φ is undefined: nothing at the end node responds to it). The displacement
     // into the device, D_in = sgn·D, adds (D_in − D_in at the step's start)/dt to the current.
     const link = ct.phi, Dstart = sgn * this.contactDStart[side];
+    // (In a steady solve, what a law in this circuit row counts of D_in: see applyConstraints in
+    // src/lawRows.js.)
+    const q = !dyn && this.steady && this.contactLaw[k] ? (this.contactQ[k] ??= { row: new Float64Array(this.sys.size + 1), D: 0, dV: 0 }) : null;
+    if (q) {
+      q.row.fill(0);
+      q.D = 0;
+      q.dV = 0;
+    }
     if (this.phiUndefined[g]) {
       this.contactD[side] = 0;
     } else if (link.type === 'capacitive') {
@@ -3422,8 +2691,9 @@ 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 (q && this.loc[b * M] >= 0) [q.D, q.row[R[b * M]], q.dV] = [Din, -Ac * link.C * VT, Ac * link.C];
       // 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).
+      // the charge it keeps in place of that (see captureLaws in src/lawRows.js).
       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;
@@ -3434,6 +2704,10 @@ export class Solver {
       // The Poisson residual is the outside's charge, D_in.
       const Din = res[R[b * M]];
       this.contactD[side] = sgn * Din;
+      if (q) {
+        q.D = Din;
+        this._captureRow(b, 0, 1, q.row);
+      }
       if (dyn && !(this.combining && this.lateStorage[g] === 1)) {
         I += (Din - Dstart) / dt;
         this._captureRow(b, 0, 1 / dt, C);
@@ -3470,92 +2744,6 @@ 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, open = st.leftOpen || st.rightOpen;
-      const { k, hi, lo } = this._flatLevel(st);
-      for (let g = st.nodes[0]; g <= st.nodes[1]; g++) {
-        const b = this.blockOfNode[g], o = b * M + 1 + i;
-        if (this.loc[o] < 0) continue;
-        this._replaceRow(b, 1 + i);
-        for (const B of this.termB) B[R[o]] = 0; // (the row's old terminal terms: the end node's own link)
-        this._j(b, 1 + i, b, 1 + i, 1);
-        res[R[o]] = u[o] - hi + (uLo[o] - lo); // (the big terms first: hi + lo rounds to hi)
-        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.
-      for (let f = st.regions[0]; f < st.regions[1]; f++) {
-        if (model.interfaces[f].links[i].type !== 'equilibrium') continue;
-        const b = this.blockOfFace[f], o = b * M + 1 + i;
-        if (this.loc[o] < 0) continue;
-        this._replaceRow(b, 1 + i);
-        for (const B of this.termB) B[R[o]] = 0;
-        this._j(b, 1 + i, b, 1 + i, 1);
-        res[R[o]] = u[o] + uLo[o];
-      }
-    }
-  }
-
-  // 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];
@@ -3620,18 +2808,19 @@ export class Solver {
   // entries; where they're huge (an inversion layer's 0.1 nm cells, a conductance ~1e11 against
   // the layer's own storage and the trickle from the bulk), eliminating them loses the layer's
   // overall level to round-off, and Newton rattles there. delta and deltaV come in as the plain
-  // solve's and leave refined (in the transformed unknowns, as _solveBordered gives them); false
+  // solve's and leave refined (in the transformed unknowns, as solveBordered gives them); false
   // if refining didn't help, leaving them as they came.
   _refine(dt, delta, deltaV) {
     const { res, termRes, termB, termC, termDI, rowDiv, floating: fl } = this;
     const N = this.sys.size, K = fl.length, pins = this.pins, R = this.rix;
-    const save = { res: Float64Array.from(res), termRes: Float64Array.from(termRes), termB: termB.map((b) => Float64Array.from(b)), termC: termC.map((c) => Float64Array.from(c)), termDI: Float64Array.from(termDI), transformed: this.transformed, pinRes: this.pins.map((p) => p.res) };
+    const save = { res: Float64Array.from(res), termRes: Float64Array.from(termRes), termB: termB.map((b) => Float64Array.from(b)), termC: termC.map((c) => Float64Array.from(c)), termDI: Float64Array.from(termDI), termDX: this.termDX.map((x) => Float64Array.from(x)), transformed: this.transformed, pinRes: this.pins.map((p) => p.res) };
     const restoreArrays = () => {
       res.set(save.res);
       termRes.set(save.termRes);
       save.termB.forEach((b, k) => termB[k].set(b));
       save.termC.forEach((c, k) => termC[k].set(c));
       termDI.set(save.termDI);
+      save.termDX.forEach((x, k) => this.termDX[k].set(x));
       this.transformed = save.transformed;
       this.pins.forEach((p, a) => (p.res = save.pinRes[a]));
     };
@@ -3646,7 +2835,7 @@ 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).
+      // A flat stretch's rows hold each level to its first node's (see flatRows in src/lawRows.js).
       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]];
@@ -3659,6 +2848,7 @@ export class Solver {
       }
       for (let a = 0; a < K; a++) {
         let t = Dk[a] * x[N + a];
+        for (let b = 0; b < K; b++) if (b !== a) t += this.termDX[fl[a]][fl[b]] * x[N + b];
         for (let j = 0; j < N; j++) t += Ck[a][j] * x[j];
         out[N + a] = t;
       }
@@ -3678,7 +2868,7 @@ export class Solver {
         p.res = rhs[R[p.row]];
         rhs[R[p.row]] = 0;
       }
-      this._solveBordered(rhs, out, outV, pins);
+      solveBordered(this, rhs, out, outV, pins);
       const z = new Float64Array(N + K);
       for (let j = 0; j < N; j++) z[j] = out[j];
       for (let a = 0; a < K; a++) z[N + a] = outV[a];
@@ -3740,7 +2930,8 @@ export class Solver {
     const history = [], ownHistory = [];
     // Refined solves (see _refine), once the plain ones stall.
     let refine = false, refined = 0, noRefine = false;
-    // Islands (see _applyIslands): their summed rows go in only once the plain solves converge.
+    // Islands (see applyIslands in src/lawRows.js): their summed rows go in only once the plain
+    // solves converge.
     // Far from the solution, Newton exact along a weakly held level takes it by 1e5 thermal
     // units (a floating base, cold at bias), where the plain solves, which barely see that level,
     // converge. Converged, an island at the wrong level shows: it takes in a different current
@@ -3820,7 +3011,7 @@ export class Solver {
       try {
         const pins = this.pins;
         deltaV.fill(0);
-        this._solveBordered(res, delta, deltaV, pins);
+        solveBordered(this, res, delta, deltaV, pins);
         if (refine && !this._refine(dt, delta, deltaV)) {
           refine = false; // (GMRES didn't converge, or strayed: the plain solves it is)
           noRefine = true;
@@ -4012,7 +3203,7 @@ export class Solver {
     this.sourceTime = this.steady ? this.steadyAt : tEnd;
     this.sourceBefore = !this.steady;
     this.combining = true;
-    this.lawForm = new Map(); // (see _circuitLaws)
+    this.lawForm = new Map(); // (see circuitLaws in src/lawRows.js)
     let result;
     try {
       result = this.newton(dtEff, opts);
@@ -4029,7 +3220,8 @@ export class Solver {
       }
       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).
+        // charging, below its metal's G Δη): once more, read by the change (see circuitLaws in
+        // src/lawRows.js).
         this.u.set(this.uPrev);
         this.uLo.set(this.uPrevLo);
         this.termV.set(this.termVPrev);
@@ -5057,7 +4249,8 @@ export class Solver {
     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.
+    // says, which the step kept exactly (see circuitLaws in src/lawRows.js); 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;
@@ -5102,7 +4295,7 @@ export class Solver {
    * 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
+   * the steady system's own rows instead (see src/laws.js): 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.
@@ -5112,7 +4305,7 @@ export class Solver {
   solveSteady(opts = {}) {
     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();
+    captureLaws(this);
     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 {
@@ -5131,7 +4324,7 @@ export class Solver {
       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;
+      if (laws.length === 0 && !chargeOnly(this, 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}` : ''}`;
@@ -5151,7 +4344,7 @@ export class Solver {
   _steadyFromHere(opts) {
     this.conditioning = null;
     this.computeConcentrations();
-    this._captureLocal(); // immobile combinations keep, node by node, what they hold now
+    captureLocal(this); // immobile combinations keep, node by node, what they hold now
     this.sourceTime = this.time;
     // Continuation applies where the right terminal is held at a voltage, against a held left one.
     const [dl, dr] = [this.terms[0].drive, this.terms[1].drive];
@@ -5247,20 +4440,7 @@ export class Solver {
   // 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');
+    return this.constraints.some((cs) => cs.terminals.includes(k)) || chargeOnly(this, k);
   }
 
   // A cold steady solve with a terminal driven by a current, which can fail where the same state