driftlet 0.6.0 → 0.7.0

package/README.md

@@ -32,12 +32,12 @@ The same equations go by different names in different fields. If your problem is
 |---|---|---|---|
 | Semiconductor devices | drift–diffusion, van Roosbroeck, quasi-Fermi levels, Scharfetter–Gummel; pn, Schottky, MOS, heterojunctions | [first example](#a-semiconductor-junction), [pn](https://markblundeberg.github.io/driftlet/demos/pn.html) and [MOS](https://markblundeberg.github.io/driftlet/demos/mos.html) demos, [`contacts`](test/contacts.test.js), [`metal`](test/metal.test.js) tests | exact built-in potential, Shockley J–V, depletion charge, MOS C–V |
 | Solar cells | photogeneration, radiative and SRH recombination | [solar](https://markblundeberg.github.io/driftlet/demos/solar.html) [organic (excitons)](https://markblundeberg.github.io/driftlet/demos/organic.html) and [perovskite (mobile ions)](https://markblundeberg.github.io/driftlet/demos/perovskite.html) demos, [`ionmonger`](test/ionmonger.test.js), [`reactions`](test/reactions.test.js) and [`generation`](test/generation.test.js) tests: generation is a reaction from a photon reservoir (uniform, or Beer–Lambert with `photogeneration()`), SRH as a rate law, in the bulk and at faces | `J_sc = qG(L_n + L_p + W)`; J_sc under Beer–Lambert against collection theory; Shockley J–V in the dark |
-| Electrochemistry | Nernst–Planck, concentration polarization, limiting current, Butler–Volmer, Warburg, cyclic voltammetry, salt bridges and liquid junctions | [second example](#an-electrochemical-cell), [cyclic voltammetry](https://markblundeberg.github.io/driftlet/demos/redox.html), [Daniell cell](https://markblundeberg.github.io/driftlet/demos/daniell.html), [saturation](https://markblundeberg.github.io/driftlet/demos/saturation.html) and [impedance](https://markblundeberg.github.io/driftlet/demos/impedance.html) demos, [`circuit`](test/circuit.test.js), [`kinetics`](test/kinetics.test.js), [`impedance`](test/impedance.test.js) tests | `i_lim·tanh(V/4V_T)`, Butler–Volmer closed form, finite-length Warburg |
+| Electrochemistry | Nernst–Planck, concentration polarization, limiting current, Butler–Volmer, Warburg, cyclic voltammetry, salt bridges and liquid junctions | [second example](#an-electrochemical-cell), [cyclic voltammetry](https://markblundeberg.github.io/driftlet/demos/redox.html), [Daniell cell](https://markblundeberg.github.io/driftlet/demos/daniell.html), [saturation](https://markblundeberg.github.io/driftlet/demos/saturation.html), [impedance](https://markblundeberg.github.io/driftlet/demos/impedance.html) and [liquid-junction](https://markblundeberg.github.io/driftlet/demos/junction.html) demos, [`circuit`](test/circuit.test.js), [`kinetics`](test/kinetics.test.js), [`impedance`](test/impedance.test.js), [`junction`](test/junction.test.js) tests | `i_lim·tanh(V/4V_T)`, Butler–Volmer closed form, finite-length Warburg; junction potentials against Henderson, Planck, JPCalc and LJPcalc |
 | Batteries, intercalation | OCV, insertion hosts, chemical diffusion | [insertion demo](https://markblundeberg.github.io/driftlet/demos/insertion.html), [`statistics`](test/statistics.test.js) test | composition vs OCV, π²D/4L² relaxation |
 | Double layers, colloids | Poisson–Boltzmann, Gouy–Chapman–Stern, Debye screening, crowding (Bikerman) | [double-layer demo](https://markblundeberg.github.io/driftlet/demos/double-layer.html), [`equilibrium`](test/equilibrium.test.js) test | Gouy–Chapman charge and profile, Kilic–Bazant–Ajdari |
 | Membranes, desalination | Donnan, ion exchange, liquid junctions, water dissociation | [membrane demo](https://markblundeberg.github.io/driftlet/demos/membrane.html), [`equilibrium`](test/equilibrium.test.js), [`neutral`](test/neutral.test.js) tests | Donnan partition, Planck EMF |
 | Solid-state ionics | mixed ionic–electronic conduction, defect chemistry, mobile ions | [`statistics`](test/statistics.test.js), [`reactions`](test/reactions.test.js) tests | mass action from standard potentials |
-| Biophysics | Poisson–Nernst–Planck, ion channels, membrane potentials | the electrochemistry setups, with fixed charge in the channel region | no dedicated check yet |
+| Biophysics, nanofluidics | charged nanochannels and pores, resting potentials, Goldman–Hodgkin–Katz, Nernst, Donnan, pumps and leaks | [charged-nanochannel](https://markblundeberg.github.io/driftlet/demos/channel.html), [resting-potential](https://markblundeberg.github.io/driftlet/demos/cell.html) and [liquid-junction](https://markblundeberg.github.io/driftlet/demos/junction.html) (a patch pipette's) demos, [`pore`](test/pore.test.js) test; a membrane as a face: a capacitor with ion permeabilities, and the Na⁺/K⁺ pump as a reaction on it ([`membrane`](test/membrane.test.js) test) | GHK potential and current–voltage curve; a resolved lipid layer; Mullins–Noda; the pump's static head; Donnan |
 
 The tests are worked setups, each with its analytic check, so they double as recipes. The
 [validation table](#validation) lists them all.
@@ -55,7 +55,7 @@ import { bandDiagram } from 'driftlet/plot';    // a level diagram as an SVG str
 ```
 
 Or straight from a CDN in a page, pinned to a version:
-`https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/index.js` (and `src/kit.js`, `src/plot.js`).
 TypeScript declarations ship in the package. Writing a demo with an LLM agent? Point it at
 [`llms.txt`](llms.txt).
 
@@ -149,7 +149,9 @@ them locally, serve the repository root (e.g. `python3 -m http.server`) and open
 | [![impedance](demos/screenshots/impedance.png)](https://markblundeberg.github.io/driftlet/demos/impedance.html) | [![ion-exchange membrane](demos/screenshots/membrane.png)](https://markblundeberg.github.io/driftlet/demos/membrane.html) | [![double layer](demos/screenshots/double-layer.png)](https://markblundeberg.github.io/driftlet/demos/double-layer.html) |
 | **Impedance**: the Warburg arc, and the cell's small-signal response inside | **Ion-exchange membrane**: Donnan steps, ion by ion, against TMS theory | **Double layer**: dilute vs crowded ions, against closed forms |
 | [![insertion host](demos/screenshots/insertion.png)](https://markblundeberg.github.io/driftlet/demos/insertion.html) | [![organic solar cell](demos/screenshots/organic.png)](https://markblundeberg.github.io/driftlet/demos/organic.html) | [![perovskite hysteresis](demos/screenshots/perovskite.png)](https://markblundeberg.github.io/driftlet/demos/perovskite.html) |
-| **Intercalation host**: cycling between cutoffs against the OCV |  |  |
+| **Intercalation host**: cycling between cutoffs against the OCV | **Organic solar cell**: excitons diffusing to a donor/acceptor interface, against theory | **Perovskite hysteresis**: mobile ions and scan rate, against IonMonger |
+| [![charged nanochannel](demos/screenshots/channel.png)](https://markblundeberg.github.io/driftlet/demos/channel.html) | [![resting potential](demos/screenshots/cell.png)](https://markblundeberg.github.io/driftlet/demos/cell.html) | [![liquid junctions](demos/screenshots/junction.png)](https://markblundeberg.github.io/driftlet/demos/junction.html) |
+| **Charged nanochannel**: selectivity, overlapping Donnan layers and rectification, against Teorell–Meyer–Sievers | **Resting potential**: leaks and the Na⁺/K⁺ pump, against Mullins–Noda; the run-down to Donnan | **Liquid junctions**: a patch pipette's against Henderson, Planck and LJPcalc; a charged frit |
 
 ## How to think about it
 
@@ -241,6 +243,9 @@ Every physics feature is tested against analytic results (`npm test`, node's bui
 | Perovskite J–V hysteresis, against IonMonger | an independent code (finite elements, Octave): mobile iodide vacancies, interface SRH, scans from 1 mV/s to 1 kV/s — hysteresis index, P_max, V_oc, the whole loop (as current where it's gentle, as a voltage offset near V_oc, where it falls at up to 1100 mA/cm² per volt) | 1.5e-3; 0.05 mW/cm²; 2 mV; 0.03 mA/cm² and 1 mV (0.010 and 0.31 mV found) |
 | Illuminated long pn diode | `J_sc = qG(L_n + L_p + W)` from a cold start; superposition at low injection | 5e-3; 1e-2 |
 | Schottky barrier (metal region \| n-Si) | surface density from the alignment; depletion charge | 5e-3; 2% |
+| Charged pore or nanochannel (resolved Donnan layers at each mouth) | conductance against salt, down to its plateau, as Teorell–Meyer–Sievers in a long pore (short ones short by end layers ∝ 1/L); the zero-current voltage across a salt gradient; a symmetric pore's I–V odd, rectification with charge on one side or bipolar | 1%; 5e-3 to 1e-4; 1e-9 |
+| Cell membrane (a capacitive face with permeabilities) | GHK resting potential (neutral or resolved solutions) and current–voltage curve; the same as a resolved 5 nm lipid layer; charging at I/C; with the Na⁺/K⁺ pump in a closed cell, Mullins–Noda, the static head 3Δμ̄_Na − 2Δμ̄_K = ΔG_ATP, and Donnan with the pump off | 1e-5 V; 3e-3; 2e-5 V; 1%; 1e-9 |
+| Liquid junctions in mixtures | Henderson's formula against JPCalc's published values; driftlet's steady junction against Planck by shooting and the stationary Nernst–Planck codes LJPcalc and JLJP, a patch pipette's K-gluconate among them; a free-diffusion junction constant in time, between the two | 0.015 mV; 2e-4 and 0.02 mV; 5e-3 mV |
 | Liquid junction, open circuit | cell EMF 2t₊(RT/F) ln(c₁/c₂); Planck diffusion potential | 1e-4 |
 | Salt diffusion mode from a `c0` profile | c̄ + a·sin(πx/2L) decaying at π²D/4L², D = 2D₊D₋/(D₊ + D₋) | 2e-5 |
 | Concentration polarization | `i = i_lim tanh(V/4V_T)`, incl. galvanostatic and load modes | 2e-4 |

package/docs/device.md

@@ -98,7 +98,8 @@ regions: [
 - `fixedCharge`: immobile charge density (doping, ionomer), C/m³. Default 0. In an insertion
   host it's balanced by background electronic carriers.
 - `c0`: initial concentrations, mol/m³: the starting state of each species given. Species
-  connected to a contact don't need it (without it, they start from that contact's level). Any
+  connected to a contact don't need it (without it, they start from that contact's level: the
+  left contact's if the species reaches it, else the right's, else a port's). Any
   other species (blocked everywhere, or only made and consumed by
   reactions) does: its `c0` fixes the amount it conserves. Concentrations are positive ($`\bar\mu`$ is
   logarithmic in them); to have none of a species in a region, leave it out of that region's
@@ -169,7 +170,8 @@ defaults to no dipole.
 
 **Species laws** `species` (default: local equilibrium, $`\bar\mu`$ continuous, where the species is
 present on both sides; blocked otherwise): `'equilibrium'`, `'blocked'`, or
-`{ type: 'conductance', G }` ($`J = G \cdot (V_L - V_R)`$, G in S/m², charged species). A species that
+`{ type: 'conductance', G }` ($`J = G \cdot (V_L - V_R)`$, G in S/m², charged species), or
+`{ type: 'permeability', P }` (P in m/s; see [membranes](#membranes)). A species that
 takes part in a reaction at the face and exists on both sides has no default: give its link
 (`'blocked'` if it crosses only through the reaction), since free crossing alongside would
 short-circuit the kinetics.
@@ -226,6 +228,54 @@ lies between the two sides (a band offset, a $`\phi`$ jump). Where one carrier i
 rate saturates at the other's capture, $`r \to v_p\,p`$: holes reaching an electron-rich layer
 recombine at $`v_p`$ however many electrons wait there, which plain mass action can't do.
 
+**Saturating kinetics** (a transporter, a pump, an enzyme: something that turns over at most so
+fast) replaces `k0` and `alpha` with `vmax` (mol/(m²·s)) and `K`, a half-saturation
+concentration (mol/m³) for every species the forward reaction consumes:
+
+```math
+r = v_{\max} \prod_{\nu<0} \left(\frac{c}{c + K}\right)^{|\nu|} \left(1 - e^{-A/RT}\right)
+```
+
+Michaelis–Menten in each substrate, it runs at $`v_{\max}`$ when they're plentiful and the driving
+force is large, and it's still exactly zero at $`A = 0`$, so a pump stalls where the free energy it
+spends is used up: its static head. The backward rate is the one detailed balance implies, and
+isn't itself saturating, so this is for reactions that run forward.
+
+### Membranes
+
+A membrane thin against everything else (a lipid bilayer, 4–5 nm) is a face. Give it a
+capacitive $`\phi`$ law, its capacitance (about 0.01 F/m², 1 µF/cm²), and a species law
+`{ type: 'permeability', P }` for each ion that crosses it, through channels or carriers. The
+flux is electrodiffusion across the membrane in a constant field (Goldman–Hodgkin–Katz),
+
+```math
+N = P\,\frac{z u\,(c_L - c_R\,e^{z u})}{e^{z u} - 1}, \qquad u = \frac{\phi_R - \phi_L}{V_T}
+```
+
+toward +x, with $`c_L`$ and $`c_R`$ at the face's two edge nodes and $`\phi_R - \phi_L`$ the capacitor's
+voltage. (It's Scharfetter–Gummel across the face, with $`D/h \to P`$; where the two sides are
+different materials, the step in standard level between them counts with $`z\Delta\phi`$, so the flux
+is still exactly zero where $`\bar\mu`$ is level.) The solutions on either side can be strictly
+neutral ($`\varepsilon = 0`$), the membrane's charge then held in each edge node's box, or resolve
+their diffuse layers ($`\varepsilon > 0`$); either way the membrane potential comes out the same, to
+a few microvolts. Pumps and other
+transporters go on the same face as reactions with saturating kinetics, for example the
+Na⁺/K⁺-ATPase between the outside (left) and the cytoplasm (right):
+
+```js nocheck
+{
+  phi: { type: 'capacitive', C: 0.01 },
+  species: { 'K+': { type: 'permeability', P: 1e-8 }, 'Na+': { type: 'permeability', P: 4e-10 }, 'Cl-': { type: 'permeability', P: 4.5e-9 }, 'A-': 'blocked' },
+  reactions: [{ equation: '3 Na+(right) + 2 K+(left) + ATP = 3 Na+(left) + 2 K+(right) + ADP', fixed: { ATP: 50e3, ADP: 0 }, vmax: 5e-7, K: { 'Na+': 10, 'K+': 1.5 } }],
+}
+```
+
+`fixed` gives ATP's hydrolysis free energy (here 50 kJ/mol, with ADP and phosphate taken
+together). Membrane potentials are $`\phi`$ differences between the two solutions, $`\phi_{\mathrm{in}} - \phi_{\mathrm{out}}`$,
+read from `sol.phi` (or a `'phi'` probe in a transient). A bath contact's terminal voltage is
+its reference species' level instead, what an electrode reversible to that species would read,
+so between two different solutions it differs from $`\Delta\phi`$ by that species' Nernst term.
+
 ### Faces next to a conductor
 
 A conductor has no $`\phi`$, so a face beside it can't take a `dipole` or `step` alignment. Its $`\phi`$
@@ -500,11 +550,13 @@ const now = dev.solution();                   // snapshot of the current state
   `dt0` (first step), `dtMax`, `budgetMs` (return after this much wall time, with
   `done: false`), `maxSteps`, `method`. The step size carries over between calls, so an
   animation can call `advance(tNext, { budgetMs })` once per frame. The solution adds `done`,
-  `rejected`, and a `trace` of terminal current and voltage after every accepted step. With
-  `probes: [{ x, species, quantity, region }]` the trace also reads a species inside the device,
-  as `trace.probes[k]` beside `trace.t`: its concentration (`quantity: 'c'`, the default, mol/m³)
-  or species voltage (`'V'`), linearly between the nodes around `x` (at an interface, `region`
-  picks the side). That's what a detector at `x` sees. Probes read at accepted steps, which grow
+  `rejected`, and a `trace` of terminal current and voltage after every accepted step (the
+  voltage is the right contact's minus the left's: what a meter between the terminals reads,
+  which at a bath is its reference species' level, not $`\phi`$). With
+  `probes: [{ x, species, quantity, region }]` the trace also reads inside the device,
+  as `trace.probes[k]` beside `trace.t`: a species' concentration (`quantity: 'c'`, the default,
+  mol/m³) or species voltage (`'V'`), or $`\phi`$ itself (`'phi'`, no species), linearly between the
+  nodes around `x` (at an interface, `region` picks the side). That's what a detector at `x` sees. Probes read at accepted steps, which grow
   as a transient slows, so give `dtMax` to resolve a signal in time.
 - `impedance(frequencies, { terminal, profiles })` solves the steady state, then linearises about
   it: $`Z(f) = \delta V/\delta I`$ in Ω·m² at one terminal (`'right'` by default), with I into the

package/docs/kit.md

@@ -169,6 +169,34 @@ const seen = run.trace.probes[0], k = seen.indexOf(Math.max(...seen));
 console.log(`the pulse passes at ${(run.trace.t[k] * 1e6).toFixed(2)} µs, Δp ≈ ${units.toPerCm3(seen[k]).toExponential(1)} cm⁻³`);
 ```
 
+## Liquid junctions
+
+`henderson(left, right, ions, { T })` and `planck(left, right, ions, { T })` give the junction
+potential $`\phi_R - \phi_L`$ (V) between two neutral solutions (mol/m³ by ion), with `ions` their
+`{ z, D }` (the data library's `IONS` has that shape):
+
+- **Henderson's** formula takes the junction to be the two solutions mixed in one proportion at
+  every point (so every ion's mixing fraction follows the same curve). It's
+  a closed form, exact for one salt, and what JPCalc and most electrophysiology corrections use.
+- **Planck's** is the steady state of diffusion through a zone held between the two solutions,
+  electroneutral and carrying no current, solved by shooting on the Nernst–Planck equations. It's
+  exact for that junction, and equal to driftlet's own steady state between two baths.
+
+A junction growing freely from first contact is neither: simulate it, as a transient from a
+`c0` step. For one salt all three agree; for mixtures they differ by up to a millivolt or so.
+Validated against JPCalc (Henderson), and LJPcalc and JLJP (stationary Nernst–Planck), in
+test/junction.test.js.
+
+```js
+import { henderson, planck, IONS } from 'driftlet/kit';
+
+// 50 mM NaCl against 50 mM KCl, and a K-gluconate pipette (gluconate's D from its relative mobility, 0.33 of K⁺'s).
+const ions = { ...IONS, 'gluconate-': { z: -1, D: 0.33 * IONS['K+'].D } };
+console.log(1000 * henderson({ 'Na+': 50, 'Cl-': 50 }, { 'K+': 50, 'Cl-': 50 }, ions), 'mV');
+const pipette = { 'K+': 140, 'gluconate-': 130, 'Cl-': 10 }, bath = { 'Na+': 145, 'K+': 5, 'Cl-': 150 };
+console.log(`Henderson ${(1000 * henderson(pipette, bath, ions)).toFixed(2)} mV, Planck ${(1000 * planck(pipette, bath, ions)).toFixed(2)} mV`);
+```
+
 ## Recording a transient
 
 `recorder(device, { every, times, probes })` runs a transient in pieces and keeps what a demo
@@ -339,7 +367,9 @@ page can show that its numbers hold up. Pass the solution `solve()` or `advance(
   prompt to look, and don't fail the check.
 - **balance**, in a steady state: each species' ledger, what comes in through each terminal and
   what each reaction (bulk, or at a face) makes or uses, in mol/(m²·s) and for a charged species
-  as a current. The terms must sum to zero. Under light it's J = F(G − R), and it says where
+  as a current. The terms must sum to zero. A species that a face lets through only by a law (a
+  membrane's permeability, a conductance) or by a reaction has a ledger on each side, with what
+  crosses as a term: in a cell, Na⁺ leaks into the cytoplasm as fast as the pump puts it out. Under light it's J = F(G − R), and it says where
   every carrier went: collected, or recombined in the bulk or at which face. A species at rest
   (in equilibrium, flows only of round-off against what it could carry) isn't listed.
 - **conservation**, in a transient: every closed, unreacting stretch keeps what it held plus
@@ -373,7 +403,7 @@ const dev = new Device(
 );
 const report = check(dev, dev.solve());
 console.log(report.text);
-// ok   balance: 2 species' sources and sinks sum to zero …
+// ok   balance: 2 ledgers sum to zero …
 //        e-: photon = e- + h+: +2.99e-3 (289 A/m²); left contact: -2.23e-3 (-215 A/m²); …
 // FAIL grid: on a grid twice as fine (172 → 339 nodes), the largest change is region 0 (Si)
 //      charge, … (0.021, over 0.01: refine the grid …): the current is fine (1e-4), but the

package/llms.txt

@@ -14,9 +14,9 @@ docs/conventions.md (signs and levels) and docs/data.md (the data library).
 From a CDN, pin the version:
 
 ```js nocheck
-import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`.
@@ -50,7 +50,7 @@ From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`.
   V_T = GAS_CONSTANT·T/FARADAY). `driftlet/kit`: `build`, `layer`, `ohmic`, `bath`, `half`,
   `level`, `SHE`, `describe`, `live`, `traces`, the sources (`pulse`, `square`, `triangle`, `ramp`,
   `injector`, `recombination`, `photogeneration`), the data library (`aqueous`, `semiconductor`,
-  `metal`, `IONS`, …), `check` (a solution's checks), `recorder` (a transient's trace and frames across calls), the curated
+  `metal`, `IONS`, …), `check` (a solution's checks), `henderson` and `planck` (liquid-junction potentials), `recorder` (a transient's trace and frames across calls), the curated
   `perovskiteCell` with IonMonger's `PEROVSKITE_SCANS` and `hysteresis`, and the vacuum-level helpers. `driftlet/plot` (a quick look; `traces()` is the data for your own charts): `bandDiagram`, `levelChart`, `labelParts` (labels mark subscripts as `V_{e⁻}`), `themeColor`.
 - **Reactions** are written as equations, `{ equation: 'e- + h+ = 0', kf: { Si: 1e8 } }`, in
   `new Device`, `build()` and `set()` alike. A coefficient is a number and a space (`2 e-`).
@@ -160,6 +160,57 @@ const oc = new Device(cell({ I: 0 })).solve(); // open circuit
 console.log(`J_sc = ${sc.current.toFixed(1)} A/m², V_oc = ${oc.terminals.right.V.toFixed(3)} V`);
 ```
 
+## Template: a cell membrane
+
+A lipid bilayer is a face: a capacitor (about 1 µF/cm², 0.01 F/m²) that ions cross through
+channels, each with a permeability (`{ type: 'permeability', P }`, m/s: electrodiffusion in a
+constant field, so Goldman–Hodgkin–Katz comes out of it), and that pumps cross as reactions with
+saturating kinetics (`vmax`, `K`). The solutions on either side can be strictly neutral. The
+membrane potential is φ_in − φ_out from `sol.phi` (a bath's terminal voltage reads its reference
+species' level instead, which differs from Δφ by that ion's Nernst term).
+
+```js
+import { Device, FARADAY, GAS_CONSTANT } from 'driftlet';
+import { build, layer, bath, aqueous, check } from 'driftlet/kit';
+
+const T = 310.15, VT = (GAS_CONSTANT * T) / FARADAY;
+const out = { 'Na+': 145, 'K+': 5, 'Cl-': 110, 'A-': 40 }; // mM = mol/m³; A⁻: anions that don't cross
+const inside = { 'Na+': 12, 'K+': 140, 'Cl-': 10, 'A-': 142 };
+const water = aqueous(['Na+', 'K+', 'Cl-'], { epsr: 0 }); // strictly neutral solutions
+water.species.push({ name: 'A-', z: -1, cRef: 1000 });
+water.materials.water.species['A-'] = { D: 0.5e-9, mu0: 0 };
+const P = { 'K+': 1e-8, 'Na+': 0.04e-8, 'Cl-': 0.45e-8 }; // m/s, Hodgkin and Katz's ratios
+const membrane = {
+  phi: { type: 'capacitive', C: 0.01 },
+  species: { 'K+': { type: 'permeability', P: P['K+'] }, 'Na+': { type: 'permeability', P: P['Na+'] }, 'Cl-': { type: 'permeability', P: P['Cl-'] }, 'A-': 'blocked' },
+  // The Na⁺/K⁺ pump (outside on the left): 3 Na⁺ out, 2 K⁺ in, per ATP (50 kJ/mol); vmax ≈ 3000
+  // pumps per µm² at 100 cycles/s.
+  reactions: [{ equation: '3 Na+(right) + 2 K+(left) + ATP = 3 Na+(left) + 2 K+(right) + ADP', fixed: { ATP: 50e3, ADP: 0 }, vmax: 5e-7, K: { 'Na+': 10, 'K+': 1.5 } }],
+};
+const cell = build({
+  T,
+  library: [water],
+  stack: [
+    bath(out, 'Cl-'), // the extracellular fluid, held
+    layer('water', 1e-6, { name: 'outside', c0: out }),
+    membrane,
+    layer('water', 5e-6, { name: 'cytoplasm', c0: inside }), // a closed cell: its contents set by leaks and the pump
+    { species: { 'Na+': 'blocked', 'K+': 'blocked', 'Cl-': 'blocked', 'A-': 'blocked' }, phi: 'neutral' },
+  ],
+  grid: { hmin: 50e-9, hmax: 200e-9 },
+});
+const dev = new Device(cell), sol = dev.solve();
+const g = sol.x.length - 1, ci = (s) => sol.c[s][g], Vm = sol.phi[g] - sol.phi[0];
+// Mullins–Noda: in steady state the pump's 3:2 sets the ratio of the Na⁺ and K⁺ leaks.
+const mn = VT * Math.log((1.5 * P['K+'] * out['K+'] + P['Na+'] * out['Na+']) / (1.5 * P['K+'] * ci('K+') + P['Na+'] * ci('Na+')));
+console.log(`V_m = ${(Vm * 1e3).toFixed(2)} mV (Mullins–Noda ${(mn * 1e3).toFixed(2)}), inside Na⁺ ${ci('Na+').toFixed(1)} K⁺ ${ci('K+').toFixed(1)} mM`);
+console.log(check(dev, sol).text); // per compartment: Na⁺ leaks into the cytoplasm as fast as it's pumped out
+```
+
+Between two baths instead (the inside one `bath(inside, 'Cl-', { I: 0 })`: held composition, no
+current), V_m is GHK. Without the pump, a closed cell runs down to Donnan equilibrium. driftlet
+has no voltage-gated channels; a permeability can be changed with `set()` between steps.
+
 ## Template: an electrode in a stirred solution
 
 One working electrode, a stagnant layer of solution, and the well-stirred bulk as a bath. The
@@ -233,8 +284,9 @@ console.log(`peak at ${(run.trace.t[k] * 1e6).toFixed(2)} µs, Δp ${units.toPer
 To start from a state instead of simulating how it got there (a packet already injected, a
 salt gradient laid down), give a region's `c0` a profile against the device's x:
 `c0: { 'h+': { x: [...], values: [...] } }`, piecewise linear. A given `c0` is the starting state,
-even for a species a contact feeds; species without one start at their contact's level, with φ
-made neutral node by node (electrons follow the holes). Then `advance()` without `solve()`, which would go straight to the steady
+even for a species a contact feeds; species without one start at their contact's level (the
+left's if they reach it, else the right's), with φ made neutral node by node (electrons follow
+the holes). Between two different solutions, give every region its `c0`. Then `advance()` without `solve()`, which would go straight to the steady
 state.
 
 Transients cost more where a carrier's density spans many decades (minority holes in silicon
@@ -255,7 +307,9 @@ The definition is plain data: print it, edit what your demo varies.
 
 `live()` merges slider moves made during a solve, warm-starts each solve and keeps the last
 good solution. `bandDiagram()` returns an SVG string. Pass `worker: true` to `live()` to solve in
-a Web Worker.
+a Web Worker (it works with the library loaded from a CDN: a same-origin stub imports it). Calling
+`set()` from `onsolution` is fine, for a quantity the page solves for itself (it queues the next
+solve), as long as it settles rather than ping-pongs.
 
 ```html
 <!doctype html>
@@ -265,9 +319,9 @@ a Web Worker.
 <span id="readout"></span>
 <div id="figure"></div>
 <script type="module">
-import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.6.0/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.7.0/src/plot.js';
 
 const def = build({
   T: 300,
@@ -384,11 +438,15 @@ has the long form):
 - **A steady solve of a closed cell where every ion can cross.** Its steady state is complete
   mixing. To watch a junction or a salt bridge, step in time from the unmixed `c0` (`advance`).
 - **Everything floating.** At least one terminal must be held at a voltage `V`.
-- **The library's semiconductors are at 300 K.** Give `T: 300`.
+- **The library's data are for 25 °C** (its semiconductors for 300 K: give `T: 300`). At body
+  temperature, `T: 310.15` with the same μ° and D is a fair start; D rises about 2% per kelvin
+  in water.
 - **Sign of the current.** `sol.current` is positive toward +x: a forward-biased diode with its
   p side on the right carries negative current. A terminal's current is into the device.
-- **Sign of a voltage across a membrane.** `sol.terminalVoltage` is V_right − V_left. Physiology
-  quotes V_inside − V_outside, so put the inside on the right or flip the sign.
+- **A membrane potential read from the terminals.** Physiology's V_m is φ_inside − φ_outside:
+  read it from `sol.phi` (or a `{ x, quantity: 'phi' }` probe in a transient), with the inside on
+  the right. `sol.terminalVoltage` (and a trace's `voltage`) is V_right − V_left of the contacts,
+  which at baths are their reference species' levels: it differs from Δφ by that ion's Nernst term.
 - **A coefficient without its space.** `'2e- + …'` reads `2e-` as a species name; the error says
   to write `2 e-`.
 - **Changing c0 with `set()`.** A carried state keeps what it holds; `c0` is only the starting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Small, dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for interactive web demos",
   "type": "module",
   "exports": {

package/src/checks.js

@@ -78,33 +78,67 @@ export function check(device, sol, { refine = true, tol = 1e-2 } = {}) {
 // Each species' steady ledger: in through the terminals, made by the reactions. Rates in
 // mol/(m²·s), positive into the device or made.
 function balance(device, sol) {
-  const { model, def } = device, { species } = model;
+  const { model, def } = device, { species, regions, interfaces } = model;
   const label = (rdef) => rdef?.equation ?? JSON.stringify(rdef?.nu ?? rdef);
-  const ledgers = species.map((sp) => ({ species: sp.name, z: sp.z, terms: [] }));
-  const add = (i, what, rate) => {
-    if (rate !== 0 && Number.isFinite(rate)) ledgers[i].terms.push({ what, rate });
+  // Each species' compartments: runs of regions it's present in, joined by faces it crosses
+  // freely (in equilibrium). A face it crosses only by a law (a permeability, a conductance) or
+  // by a reaction divides them, and what crosses there is a term in each side's ledger.
+  const ledgers = [], home = species.map(() => new Int32Array(regions.length).fill(-1));
+  species.forEach((sp, i) => {
+    let open = null;
+    regions.forEach((reg, r) => {
+      if (!model.materials[reg.material].present[i]) return void (open = null);
+      if (open && interfaces[r - 1].links[i].type === 'equilibrium') open.regions.push(r);
+      else ledgers.push((open = { species: sp.name, z: sp.z, i, regions: [r], terms: [] }));
+      home[i][r] = ledgers.length - 1;
+    });
+  });
+  const add = (i, r, what, rate) => {
+    const l = home[i][r];
+    if (!(l >= 0 && rate !== 0 && Number.isFinite(rate))) return;
+    const same = ledgers[l].terms.find((t) => t.what === what); // a bulk reaction, region by region
+    if (same) same.rate += rate;
+    else ledgers[l].terms.push({ what, rate });
   };
+  const last = regions.length - 1;
   species.forEach((sp, i) => {
-    add(i, 'left contact', sol.contacts.left.flux[sp.name]);
-    add(i, 'right contact', -sol.contacts.right.flux[sp.name]);
-    sol.ports.forEach((p) => add(i, `port ${p.name}`, p.flux[sp.name]));
+    add(i, 0, 'left contact', sol.contacts.left.flux[sp.name]);
+    add(i, last, 'right contact', -sol.contacts.right.flux[sp.name]);
+    model.ports.forEach((port, k) => add(i, port.region, `port ${sol.ports[k].name}`, sol.ports[k].flux[sp.name]));
   });
   model.reactions.forEach((rx, k) => {
-    const total = sol.bulkReactions[k].total, what = label(def.bulkReactions?.[k]);
-    for (const { i, nu } of rx.reactants) add(i, what, -nu * total);
-    for (const { i, nu } of rx.products) add(i, what, nu * total);
+    const what = label(def.bulkReactions?.[k]);
+    sol.bulkReactions[k].regions.forEach((total, r) => {
+      for (const { i, nu } of rx.reactants) add(i, r, what, -nu * total);
+      for (const { i, nu } of rx.products) add(i, r, what, nu * total);
+    });
   });
-  model.interfaces.forEach((itf, f) => {
+  interfaces.forEach((itf, f) => {
+    // Across the face, where it divides a species' compartments.
+    species.forEach((sp, i) => {
+      const type = itf.links[i].type;
+      if (type === 'equilibrium' || type === 'blocked') return;
+      const N = sol.interfaces[f].N[sp.name];
+      add(i, f, `across face ${f} (${type})`, -N);
+      add(i, f + 1, `across face ${f} (${type})`, N);
+    });
     itf.reactions.forEach((rx, k) => {
       const rate = sol.interfaces[f].rates[k], what = `${label(def.interfaces?.[f]?.reactions?.[k])} at face ${f}`;
-      for (const { i, nu } of rx.part) add(i, what, nu * rate);
+      for (const { i, nu, side } of rx.part) add(i, f + side, what, nu * rate);
     });
   });
+  // A species in one compartment is named alone; one in several, by where.
+  const several = species.map((_, i) => ledgers.filter((l) => l.i === i).length > 1);
+  for (const l of ledgers) {
+    const names = l.regions.map((r) => sol.regions[r].name);
+    l.compartment = names.length === 1 ? names[0] : `${names[0]} to ${names.at(-1)}`;
+    l.title = several[l.i] ? `${l.species} in ${l.compartment}` : l.species;
+  }
 
   // A species at rest (nothing beyond round-off moving, against what it could carry) isn't reported.
   const size = (l) => Math.max(0, ...l.terms.map((t) => Math.abs(t.rate)));
   const natural = naturalScales(device, sol);
-  const moving = ledgers.filter((l, i) => size(l) > 1e-9 * natural[i]);
+  const moving = ledgers.filter((l) => size(l) > 1e-9 * natural[l.i]);
   let worst = 0;
   const lines = [];
   for (const l of moving) {
@@ -114,13 +148,13 @@ function balance(device, sol) {
     // Terms that matter, largest first; a charged species' as a current too.
     const shown = l.terms.filter((t) => Math.abs(t.rate) > 1e-6 * size(l)).sort((a, b) => Math.abs(b.rate) - Math.abs(a.rate));
     const amp = (r) => (l.z !== 0 ? ` (${sig(FARADAY * Math.abs(l.z) * r)} A/m²)` : '');
-    lines.push(`${l.species}: ${shown.map((t) => `${t.what}: ${t.rate > 0 ? '+' : ''}${sig(t.rate)}${amp(t.rate)}`).join('; ')}`);
+    lines.push(`${l.title}: ${shown.map((t) => `${t.what}: ${t.rate > 0 ? '+' : ''}${sig(t.rate)}${amp(t.rate)}`).join('; ')}`);
   }
   const ok = worst < 1e-6;
   const summary =
     moving.length === 0
       ? 'nothing flows or reacts (equilibrium)'
-      : `${moving.length} species' sources and sinks sum to zero ${ok ? `(to ${sig(worst, 1)})` : `only to ${sig(worst, 2)}: not a steady state`}; mol/(m²·s), + in or made`;
+      : `${moving.length === 1 ? 'one ledger sums' : `${moving.length} ledgers sum`} to zero ${ok ? `(to ${sig(worst, 1)})` : `only to ${sig(worst, 2)}: not a steady state`}: each species' sources and sinks, mol/(m²·s), + in or made`;
   // The largest current any charged species carries anywhere: the scale a net current is read against.
   const gross = Math.max(0, ...moving.filter((l) => l.z !== 0).map((l) => FARADAY * Math.abs(l.z) * size(l)));
   return { name: 'balance', ok, summary, details: { ledgers, worst, lines, gross } };

package/src/describe.js

@@ -186,8 +186,15 @@ export function describe(def) {
       const law = itf.phi.type === 'capacitive' ? `capacitive, C = ${num(itf.phi.C)} F/m²` : itf.phi.type;
       const align = itf.conductor ? (itf.phi.type === 'capacitive' ? `, zeroCharge ${num(itf.zeroCharge)} V` : '') : itf.phi.type === 'neutral' ? '' : `, dipole ${num(itf.dipole)} V`;
       const blocked = species.filter((sp, i) => itf.links[i].type === 'blocked' && materials[L.material].present[i] && materials[R.material].present[i]).map((sp) => sp.name);
-      const rx = (idef.reactions ?? []).map((r) => r.equation ?? equation(r.left, r.right));
-      lines.push(`  ${L.name} | ${R.name}: ${law}${align}${blocked.length ? `; blocked: ${blocked.join(', ')}` : ''}${rx.length ? `; reactions: ${rx.join('; ')}` : ''}`);
+      const kinetics = (r) => (r.vmax !== undefined ? ` (saturating, vmax ${num(r.vmax)} mol/(m²·s))` : r.srh ? ' (SRH)' : '');
+      const rx = (idef.reactions ?? []).map((r) => (r.equation ?? equation(r.left, r.right)) + kinetics(r));
+      const laws = species.flatMap((sp, i) => {
+        const l = itf.links[i];
+        return l.type === 'permeability' ? [`${sp.name} ${num(l.P)} m/s`] : l.type === 'conductance' ? [`${sp.name} ${num(l.G)} S/m²`] : [];
+      });
+      lines.push(
+        `  ${L.name} | ${R.name}: ${law}${align}${laws.length ? `; crossing by a law: ${laws.join(', ')}` : ''}${blocked.length ? `; blocked: ${blocked.join(', ')}` : ''}${rx.length ? `; reactions: ${rx.join('; ')}` : ''}`,
+      );
     });
   }
 

package/src/device.js

@@ -16,7 +16,7 @@ export { DeviceError };
 
 // Contacts use the same laws as internal faces: the outside is a phase with known levels.
 const SPECIES_LINK_TYPES = new Set(['blocked', 'equilibrium', 'conductance', 'exchange']);
-const INTERFACE_LINK_TYPES = new Set(['equilibrium', 'blocked', 'conductance']);
+const INTERFACE_LINK_TYPES = new Set(['equilibrium', 'blocked', 'conductance', 'permeability']);
 const PHI_LINK_TYPES = new Set(['bulk', 'neutral', 'capacitive', 'pinned']);
 const GRID_FIELDS = ['hmin', 'hmax', 'ratio', 'minCells'];
 // The fields of each kind of species link (to an outside phase, or across a face).
@@ -433,12 +433,17 @@ function stoichiometry(map, path, fixed, fixedPath, species, speciesIndex, RT) {
 //   r = k0 Π_{ν<0} (c/c_ref)^{|ν|(1−α)} Π_{ν>0} (c/c_ref)^{να} (e^{αa} − e^{−(1−α)a})
 // (a conductor's carrier has activity 1, so no factor). That's mass action with rate constants
 // that depend on the electrical part of the affinity, and exactly zero at A = 0.
+// Or saturating (a transporter or an enzyme that turns over at most vmax per area): with K a
+// half-saturation concentration for each species the forward reaction consumes,
+//   r = vmax Π_{ν<0} (c/(c + K))^{|ν|} (1 − e^{−a}),
+// Michaelis–Menten in each substrate, and still exactly zero at A = 0 (the backward rate is the
+// one detailed balance implies).
 function normalizeFaceReactions(idef, where, matL, matR, species, speciesIndex, RT) {
   need(idef.reactions === undefined || Array.isArray(idef.reactions), `${where}.reactions must be an array`);
   return (idef.reactions ?? []).map((rdef, k) => {
     const rpath = `${where}.reactions[${k}]`;
     need(isObject(rdef), `${rpath} must be { equation, fixed, k0, alpha } or { left, right, fixed, k0, alpha }`);
-    fields(rdef, rpath, ['equation', 'left', 'right', 'fixed', 'k0', 'alpha', 'srh']);
+    fields(rdef, rpath, ['equation', 'left', 'right', 'fixed', 'k0', 'alpha', 'srh', 'vmax', 'K']);
     let sides = rdef;
     if (rdef.equation !== undefined) {
       need(rdef.left === undefined && rdef.right === undefined, `${rpath}: give the reaction as an equation or as left and right, not both`);
@@ -458,6 +463,22 @@ function normalizeFaceReactions(idef, where, matL, matR, species, speciesIndex,
     }
     need(part.length > 0, `${rpath}: no species participate`);
     need(charge === 0, `${rpath}: charge is not balanced (Σ ν z = ${charge})`);
+    if (rdef.vmax !== undefined || rdef.K !== undefined) {
+      need(rdef.k0 === undefined && rdef.alpha === undefined && rdef.srh === undefined, `${rpath}: give vmax and K (saturating), srh, or k0 and alpha (Butler–Volmer), one of them`);
+      const vmax = positive(rdef.vmax, `${rpath}.vmax (mol/(m²·s))`);
+      need(isObject(rdef.K), `${rpath}.K must map each species the forward reaction consumes to its half-saturation concentration (mol/m³)`);
+      for (const name of Object.keys(rdef.K)) {
+        need(part.some((p) => p.nu < 0 && species[p.i].name === name), `${rpath}.K.${name}: not a species the forward reaction consumes`);
+        positive(rdef.K[name], `${rpath}.K.${name} (mol/m³)`);
+      }
+      for (const p of part) {
+        if (p.nu >= 0) continue;
+        const mat = p.side ? matR : matL;
+        need(!mat.conductor, `${rpath}: saturating kinetics is for dissolved substrates, not a metal's ${species[p.i].name}`);
+        need(rdef.K[species[p.i].name] !== undefined, `${rpath}.K.${species[p.i].name}: give a half-saturation concentration for every species the forward reaction consumes`);
+      }
+      return { part, fixedA, vmax, K: part.map((p) => (p.nu < 0 ? rdef.K[species[p.i].name] : 0)) };
+    }
     if (rdef.srh !== undefined) {
       need(rdef.k0 === undefined && rdef.alpha === undefined, `${rpath}: give srh or k0 (and alpha), not both`);
       const srh = srhLaw(rdef.srh, `${rpath}.srh`, part, species, ['vn', 'vp']);
@@ -741,7 +762,8 @@ function normalizeInterface(idef, f, regions, materials, species, speciesIndex,
   const sheetCharge = idef.sheetCharge === undefined ? 0 : finite(idef.sheetCharge, `${where}.sheetCharge`);
 
   // Per-species laws across the face: local equilibrium (default where present on both sides),
-  // blocked, or an ohmic interface conductance G (S/m²).
+  // blocked, an ohmic interface conductance G (S/m²), or a permeability P (m/s): electrodiffusion
+  // through a thin membrane in a constant field, Goldman–Hodgkin–Katz.
   const links = defaultInterfaceLinks(matL, matR, species);
   if (idef.species !== undefined) {
     need(isObject(idef.species), `${where}.species must map species names to interface links`);
@@ -751,12 +773,16 @@ function normalizeInterface(idef, f, regions, materials, species, speciesIndex,
       const i = speciesIndex.get(sname);
       const link = typeof raw === 'string' ? { type: raw } : raw;
       need(isObject(link) && INTERFACE_LINK_TYPES.has(link.type), `${lpath}.type must be one of ${[...INTERFACE_LINK_TYPES].join(', ')}`);
-      fields(link, lpath, link.type === 'conductance' ? ['type', 'G'] : ['type']);
+      fields(link, lpath, link.type === 'conductance' ? ['type', 'G'] : link.type === 'permeability' ? ['type', 'P'] : ['type']);
       if (link.type !== 'blocked') need(matL.present[i] && matR.present[i], `${lpath}: '${sname}' must be present on both sides`);
       if (link.type === 'conductance') {
         need(species[i].z !== 0, `${lpath}: a conductance link needs a charged species`);
         positive(link.G, `${lpath}.G`);
       }
+      if (link.type === 'permeability') {
+        positive(link.P, `${lpath}.P (m/s)`);
+        need(matL.modelOf[i] < 0 && matR.modelOf[i] < 0, `${lpath}: a permeability link needs ideal (dilute) statistics for '${sname}' on both sides`);
+      }
       links[i] = { ...link };
     }
   }
@@ -847,6 +873,7 @@ function normalizeConductorInterface(idef, where, matL, matR, species, speciesIn
       const i = speciesIndex.get(sname);
       const link = typeof raw === 'string' ? { type: raw } : raw;
       need(isObject(link) && INTERFACE_LINK_TYPES.has(link.type), `${lpath}.type must be one of ${[...INTERFACE_LINK_TYPES].join(', ')}`);
+      need(link.type !== 'permeability', `${lpath}: a permeability link is for a membrane between two solutions, not at a conductor`);
       fields(link, lpath, link.type === 'conductance' ? ['type', 'G'] : ['type']);
       if (link.type !== 'blocked') need(matL.present[i] && matR.present[i], `${lpath}: '${sname}' must be present on both sides`);
       if (link.type === 'conductance') {

package/src/index.js

@@ -160,7 +160,7 @@ export class Device {
    * (one array per probe, alongside `trace.t`): what a detector at x sees.
    * @param {number} tEnd s
    * @param {{ tol?: number, dt0?: number, dtMax?: number, budgetMs?: number, maxSteps?: number, method?: 'bdf2' | 'be',
-   *   probes?: { x: number, species: string, quantity?: 'c' | 'V', region?: string | number }[] }} [opts]
+   *   probes?: { x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number }[] }} [opts]
    * @returns {Solution}
    */
   advance(tEnd, opts) {

package/src/junction.js

@@ -0,0 +1,164 @@
+// Liquid-junction potentials from formulas, for driftlet/kit: the diffusion potential φ_R − φ_L
+// between two neutral solutions, as the classical theories give it. A device simulates the actual
+// junction (steady between two baths, it is Planck's; stepping from a sharp boundary, a free
+// diffusion junction); these are for comparison, and for quick estimates.
+
+import { DeviceError } from './errors.js';
+import { FARADAY, GAS_CONSTANT } from './constants.js';
+
+const fail = (message) => {
+  throw new DeviceError(message);
+};
+
+// The ions both solutions name, with their charge and diffusivity, and both concentrations.
+function prepare(left, right, ions, what) {
+  const names = [...new Set([...Object.keys(left), ...Object.keys(right)])];
+  return names.map((name) => {
+    const ion = ions[name];
+    if (!ion || !Number.isFinite(ion.z) || !(ion.D > 0)) fail(`${what}: no { z, D } for '${name}' in the ions given`);
+    const cL = left[name] ?? 0, cR = right[name] ?? 0;
+    if (!(cL >= 0 && cR >= 0)) fail(`${what}: concentrations must be ≥ 0 (mol/m³), got ${name} ${cL} and ${cR}`);
+    return { name, z: ion.z, D: ion.D, cL, cR };
+  });
+}
+function neutral(list, side, what) {
+  let q = 0, s = 0;
+  for (const p of list) {
+    q += p.z * p[side];
+    s += Math.abs(p.z * p[side]);
+  }
+  if (Math.abs(q) > 1e-9 * s) fail(`${what}: the ${side === 'cL' ? 'left' : 'right'} solution carries a net charge (Σ z·c = ${q.toPrecision(3)} mol/m³)`);
+}
+
+/**
+ * Henderson's liquid-junction potential, φ_R − φ_L (V): the junction taken to be the two solutions
+ * mixed in one proportion at every point (every ion's mixing fraction the same curve). Exact for a single binary salt, a close estimate otherwise (it's what
+ * JPCalc and most electrophysiology corrections use).
+ * @param {Record<string, number>} left mol/m³ by ion
+ * @param {Record<string, number>} right mol/m³ by ion
+ * @param {Record<string, { z: number, D: number }>} ions charge and diffusivity (m²/s), e.g. IONS
+ * @param {{ T?: number }} [opts] K (default 298.15)
+ */
+export function henderson(left, right, ions, { T = 298.15 } = {}) {
+  const list = prepare(left, right, ions, 'henderson');
+  neutral(list, 'cL', 'henderson');
+  neutral(list, 'cR', 'henderson');
+  let a = 0, b = 0, gL = 0, gR = 0;
+  for (const { z, D, cL, cR } of list) {
+    a += z * D * (cR - cL);
+    b += z * z * D * (cR - cL);
+    gL += z * z * D * cL;
+    gR += z * z * D * cR;
+  }
+  const VT = (GAS_CONSTANT * T) / FARADAY;
+  if (b === 0) return 0;
+  return (-VT * a * Math.log(gR / gL)) / b;
+}
+
+/**
+ * Planck's liquid-junction potential, φ_R − φ_L (V): the steady state of constrained diffusion,
+ * a junction zone held between the two solutions, electroneutral, carrying no current. Solved by
+ * shooting on the Nernst–Planck equations across it (its length drops out). Exact for that
+ * junction; equal to Henderson's for a single binary salt.
+ * @param {Record<string, number>} left mol/m³ by ion
+ * @param {Record<string, number>} right mol/m³ by ion
+ * @param {Record<string, { z: number, D: number }>} ions charge and diffusivity (m²/s), e.g. IONS
+ * @param {{ T?: number, steps?: number }} [opts] K (default 298.15); RK4 steps across (default 4000)
+ */
+export function planck(left, right, ions, { T = 298.15, steps = 4000 } = {}) {
+  const list = prepare(left, right, ions, 'planck');
+  neutral(list, 'cL', 'planck');
+  neutral(list, 'cR', 'planck');
+  const n = list.length, z = list.map((p) => p.z), D = list.map((p) => p.D), Dmax = Math.max(...D);
+  const scale = Math.max(...list.map((p) => Math.max(p.cL, p.cR)));
+  const cL = list.map((p) => p.cL / scale), cR = list.map((p) => p.cR / scale);
+  // Across the zone (x from 0 to 1, D's scale dropping out with its length), each ion's flux J_i is
+  // constant: c_i' = −J_i/D_i − z_i c_i ψ', with ψ = Fφ/RT, and neutrality fixes the field,
+  // ψ' = −Σ(z_i J_i/D_i)/Σ(z_i² c_i). Integrated from the left; the fluxes are chosen so the
+  // right comes out as given and no current flows.
+  const deriv = (c, J, out) => {
+    let num = 0, den = 0;
+    for (let i = 0; i < n; i++) {
+      num += (z[i] * J[i]) / D[i];
+      den += z[i] * z[i] * Math.max(c[i], 0);
+    }
+    const dpsi = -num / den;
+    for (let i = 0; i < n; i++) out[i] = -J[i] / D[i] - z[i] * c[i] * dpsi;
+    return dpsi;
+  };
+  const shoot = (J) => {
+    const c = cL.slice(), k1 = new Float64Array(n), k2 = new Float64Array(n), k3 = new Float64Array(n), k4 = new Float64Array(n), t = new Float64Array(n);
+    const h = 1 / steps;
+    let psi = 0;
+    for (let s = 0; s < steps; s++) {
+      const p1 = deriv(c, J, k1);
+      for (let i = 0; i < n; i++) t[i] = c[i] + (h / 2) * k1[i];
+      const p2 = deriv(t, J, k2);
+      for (let i = 0; i < n; i++) t[i] = c[i] + (h / 2) * k2[i];
+      const p3 = deriv(t, J, k3);
+      for (let i = 0; i < n; i++) t[i] = c[i] + h * k3[i];
+      const p4 = deriv(t, J, k4);
+      for (let i = 0; i < n; i++) c[i] += (h / 6) * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
+      psi += (h / 6) * (p1 + 2 * p2 + 2 * p3 + p4);
+    }
+    return { c, psi };
+  };
+  // Residuals: n − 1 ions reaching the right (the last follows by neutrality), and no current.
+  const residual = (J) => {
+    const { c, psi } = shoot(J), r = new Float64Array(n);
+    for (let i = 0; i < n - 1; i++) r[i] = c[i] - cR[i];
+    let I = 0;
+    for (let i = 0; i < n; i++) I += z[i] * J[i];
+    r[n - 1] = I / Dmax; // scaled like the concentrations
+    return { r, psi };
+  };
+  let J = list.map((_, i) => -D[i] * (cR[i] - cL[i])); // plain diffusion to start
+  let { r, psi } = residual(J);
+  for (let it = 0; it < 50; it++) {
+    const norm = Math.max(...r.map(Math.abs));
+    if (norm < 1e-12) break;
+    // Newton with a finite-difference Jacobian.
+    const Jac = [];
+    for (let k = 0; k < n; k++) {
+      const dJ = 1e-7 * Math.max(Math.abs(J[k]), 1e-3 * D[k]), Jp = J.slice();
+      Jp[k] += dJ;
+      const rp = residual(Jp).r;
+      Jac.push(Array.from(rp, (v, i) => (v - r[i]) / dJ));
+    }
+    const step = solveDense(Jac, r, n);
+    let lambda = 1, next;
+    for (;;) {
+      const Jn = J.map((v, k) => v - lambda * step[k]);
+      next = residual(Jn);
+      if (Math.max(...next.r.map(Math.abs)) < norm || lambda < 1e-3) {
+        J = Jn;
+        break;
+      }
+      lambda /= 2;
+    }
+    ({ r, psi } = next);
+  }
+  if (!(Math.max(...r.map(Math.abs)) < 1e-8)) fail('planck: the shooting did not converge');
+  return ((GAS_CONSTANT * T) / FARADAY) * psi;
+}
+
+// Solves Σ_k A[k][i] x_k = b_i (A given column by column), by Gaussian elimination with pivoting.
+function solveDense(cols, b, n) {
+  const M = Array.from({ length: n }, (_, i) => [...cols.map((col) => col[i]), b[i]]);
+  for (let p = 0; p < n; p++) {
+    let best = p;
+    for (let i = p + 1; i < n; i++) if (Math.abs(M[i][p]) > Math.abs(M[best][p])) best = i;
+    [M[p], M[best]] = [M[best], M[p]];
+    for (let i = p + 1; i < n; i++) {
+      const f = M[i][p] / M[p][p];
+      for (let j = p; j <= n; j++) M[i][j] -= f * M[p][j];
+    }
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let s = M[i][n];
+    for (let j = i + 1; j < n; j++) s -= M[i][j] * x[j];
+    x[i] = s / M[i][i];
+  }
+  return x;
+}

package/src/kit.js

@@ -12,6 +12,7 @@ export { live } from './live.js';
 export { pulse, square, triangle, ramp, injector, recombination, photogeneration } from './sources.js';
 export { describe, unitWarnings } from './describe.js';
 export { recorder } from './recorder.js';
+export { henderson, planck } from './junction.js';
 export { check } from './checks.js';
 export { perovskiteCell, PEROVSKITE_SCANS, hysteresis } from './devices.js';
 export { IONS, H2O, WATER_EPSR, SEMICONDUCTORS, METALS, aqueous, semiconductor, metal } from './data.js';

package/src/recorder.js

@@ -15,7 +15,7 @@ const now = () => (typeof performance !== 'undefined' ? performance.now() : Date
  * neither, at the end of each `advance()` call. The trace (`t`, `current`, `voltage`, and
  * `probes` if given) runs from the start through every accepted step of every call.
  * @param {import('./index.js').Device} device
- * @param {{ every?: number, times?: number[], probes?: { x: number, species: string, quantity?: 'c' | 'V', region?: string | number }[] }} [opts]
+ * @param {{ every?: number, times?: number[], probes?: { x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number }[] }} [opts]
  */
 export function recorder(device, opts = {}) {
   const { every, times, probes } = opts;

package/src/solver.js

@@ -995,6 +995,22 @@ export class Solver {
         }
       }
     }
+    // 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
+    // that a transient's first reading means something.
+    const level = (side) => {
+      const ct = model.contacts[side], i = ct.terminal;
+      if (i === null || ct.species[i].type !== 'equilibrium' || z[i] === 0) return NaN;
+      const b = this.blockOfNode[side === 'left' ? 0 : grid.nNodes - 1];
+      return (this.VT * u[b * M + 1 + i]) / z[i] - ct.species[i].offset;
+    };
+    for (const k of this.floating) {
+      const t = this.terms[k], held = k === 0 ? 1 : 0;
+      if (t.kind === 'port' || held >= this.terms.length || this.floating.includes(held)) continue;
+      const shift = level(t.side) - level(this.terms[held].side);
+      if (Number.isFinite(shift)) this.termV[k] = this.termV[held] + shift;
+    }
     this.computeConcentrations();
   }
 
@@ -1538,6 +1554,27 @@ export class Solver {
         res[R[o]] = -deta; // μ̄ continuous
         this._j(bf, r, bR, r, 1);
         this._j(bf, r, bL, r, -1);
+      } else if (type === 'permeability') {
+        // Electrodiffusion through a thin membrane in a constant field: Scharfetter–Gummel across
+        // the face with D/h → P, its drift taken over the face's whole jump in the standard level
+        // zφ̂ + μ°/RT − ln c_ref (the φ jump of a capacitive face, and any step between the two
+        // materials). Between like solutions it's Goldman–Hodgkin–Katz's flux,
+        //   N = P·zu·(c_L − c_R e^{zu})/(e^{zu} − 1),  u = (φ_R − φ_L)/V_T,
+        // and it's exactly zero where μ̄ is level.
+        const gl = grid.regionEnd[f], gr = gl + 1, kl = gl * n + i, kr = gr * n + i, zi = z[i], P = itf.links[i].P;
+        const shift = this.mu0hat[kr] - this.mu0hat[kl] - Math.log(this.cRef[kr] / this.cRef[kl]);
+        const d = zi * (u[bR * M] - u[bL * M] + (uLo[bR * M] - uLo[bL * M])) + shift;
+        const E = Math.expm1(-deta); // η_R − η_L
+        const gBc = P * bernoulli(d) * this.c[kl];
+        const dNdd = -P * bernoulliDerivative(d) * this.c[kl] * E;
+        res[R[o]] = u[o] + gBc * E;
+        this._j(bf, r, bf, r, 1);
+        this._j(bf, r, bL, r, -gBc);
+        this._j(bf, r, bR, r, gBc * (E + 1));
+        if (zi !== 0) {
+          this._j(bf, r, bL, 0, zi * dNdd - zi * gBc * E);
+          this._j(bf, r, bR, 0, -zi * dNdd);
+        }
       } else {
         // conductance: J = G (V_L − V_R), V = V_T η / z  ⇒  N = G V_T (η_L − η_R) / (z² F)
         const gG = (itf.links[i].G * VT) / (z[i] * z[i] * F);
@@ -1780,12 +1817,28 @@ export class Solver {
       const g = p.side ? gR : gL, b = p.side ? bR : bL, o = b * M + 1 + p.i;
       aHi -= p.nu * u[o];
       aLo -= p.nu * uLo[o];
-      if (rx.srh || this.nodeConductor[g] === p.i) continue; // a conductor's carrier has activity 1
+      if (rx.srh || rx.vmax || this.nodeConductor[g] === p.i) continue; // a conductor's carrier has activity 1
       const e = p.nu < 0 ? -p.nu * (1 - al) : p.nu * al;
       pref *= powr(c[g * n + p.i] / this.cRef[g * n + p.i], e);
       this._dlnc(g, p.i, e, p.side ? dR : dL);
     }
-    if (rx.srh) {
+    if (rx.vmax) {
+      // Saturating: r = vmax Π (c/(c + K))^{|ν|} (1 − e^{−a}); ∂ln S/∂ln c = |ν| K/(c + K).
+      let S = 1;
+      rx.part.forEach((p, q) => {
+        if (p.nu >= 0) return;
+        const g = p.side ? gR : gL, cc = c[g * n + p.i], K = rx.K[q];
+        S *= powi(cc / (cc + K), -p.nu);
+        this._dlnc(g, p.i, (-p.nu * K) / (cc + K), p.side ? dR : dL);
+      });
+      const a = aHi + aLo, back = Math.exp(-a);
+      rate = rx.vmax * S * -Math.expm1(-a);
+      for (let s = 0; s < M; s++) {
+        dL[s] *= rate;
+        dR[s] *= rate;
+      }
+      for (const p of rx.part) (p.side ? dR : dL)[1 + p.i] -= rx.vmax * S * back * p.nu;
+    } else if (rx.srh) {
       // SRH, with n and p each at its own side's edge node.
       const { n: pn, p: pp } = rx.srh, gn = pn.side ? gR : gL, gq = pp.side ? gR : gL;
       const s = this._srhRate(rx.srh, c[gn * n + pn.i], c[gq * n + pp.i], aHi + aLo);
@@ -2447,10 +2500,10 @@ export class Solver {
     if (!Array.isArray(probes)) fail('advance: probes must be an array of { x, species, quantity, region }');
     const plan = probes.map((p, k) => {
       const path = `advance: probes[${k}]`;
-      const i = species.findIndex((sp) => sp.name === p?.species);
-      if (i < 0) fail(`${path}.species: no species ${JSON.stringify(p?.species)}`);
-      const quantity = p.quantity ?? 'c';
-      if (quantity !== 'c' && quantity !== 'V') fail(`${path}.quantity must be 'c' (mol/m³) or 'V' (the species voltage)`);
+      const quantity = p?.quantity ?? 'c';
+      if (quantity !== 'c' && quantity !== 'V' && quantity !== 'phi') fail(`${path}.quantity must be 'c' (mol/m³), 'V' (the species voltage) or 'phi' (φ, V)`);
+      const i = quantity === 'phi' ? -1 : species.findIndex((sp) => sp.name === p?.species);
+      if (quantity !== 'phi' && i < 0) fail(`${path}.species: no species ${JSON.stringify(p?.species)}`);
       if (quantity === 'V' && species[i].z === 0) fail(`${path}: '${p.species}' is neutral, so it has no voltage; read 'c'`);
       const x = grid.x, inside = (r) => p.x >= x[grid.regionStart[r]] && p.x <= x[grid.regionEnd[r]];
       let r;
@@ -2470,6 +2523,7 @@ export class Solver {
     const out = plan.map(() => []);
     const { n, M } = this;
     const at = (q, g) => {
+      if (q.quantity === 'phi') return this.phiUndefined[g] ? NaN : this.VT * (this.u[this.blockOfNode[g] * M] + this.uLo[this.blockOfNode[g] * M]);
       if (!this.present[g * n + q.i]) return NaN;
       if (q.quantity === 'c') return this.c[g * n + q.i];
       const o = this.blockOfNode[g] * M + 1 + q.i;

package/types/index.d.ts

@@ -51,7 +51,7 @@ export class Device {
      * (one array per probe, alongside `trace.t`): what a detector at x sees.
      * @param {number} tEnd s
      * @param {{ tol?: number, dt0?: number, dtMax?: number, budgetMs?: number, maxSteps?: number, method?: 'bdf2' | 'be',
-     *   probes?: { x: number, species: string, quantity?: 'c' | 'V', region?: string | number }[] }} [opts]
+     *   probes?: { x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number }[] }} [opts]
      * @returns {Solution}
      */
     advance(tEnd: number, opts?: {
@@ -63,8 +63,8 @@ export class Device {
         method?: "bdf2" | "be";
         probes?: {
             x: number;
-            species: string;
-            quantity?: "c" | "V";
+            species?: string;
+            quantity?: "c" | "V" | "phi";
             region?: string | number;
         }[];
     }): Solution;

package/types/junction.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Henderson's liquid-junction potential, φ_R − φ_L (V): the junction taken to be the two solutions
+ * mixed in one proportion at every point (every ion's mixing fraction the same curve). Exact for a single binary salt, a close estimate otherwise (it's what
+ * JPCalc and most electrophysiology corrections use).
+ * @param {Record<string, number>} left mol/m³ by ion
+ * @param {Record<string, number>} right mol/m³ by ion
+ * @param {Record<string, { z: number, D: number }>} ions charge and diffusivity (m²/s), e.g. IONS
+ * @param {{ T?: number }} [opts] K (default 298.15)
+ */
+export function henderson(left: Record<string, number>, right: Record<string, number>, ions: Record<string, {
+    z: number;
+    D: number;
+}>, { T }?: {
+    T?: number;
+}): number;
+/**
+ * Planck's liquid-junction potential, φ_R − φ_L (V): the steady state of constrained diffusion,
+ * a junction zone held between the two solutions, electroneutral, carrying no current. Solved by
+ * shooting on the Nernst–Planck equations across it (its length drops out). Exact for that
+ * junction; equal to Henderson's for a single binary salt.
+ * @param {Record<string, number>} left mol/m³ by ion
+ * @param {Record<string, number>} right mol/m³ by ion
+ * @param {Record<string, { z: number, D: number }>} ions charge and diffusivity (m²/s), e.g. IONS
+ * @param {{ T?: number, steps?: number }} [opts] K (default 298.15); RK4 steps across (default 4000)
+ */
+export function planck(left: Record<string, number>, right: Record<string, number>, ions: Record<string, {
+    z: number;
+    D: number;
+}>, { T, steps }?: {
+    T?: number;
+    steps?: number;
+}): number;

package/types/kit.d.ts

@@ -61,5 +61,6 @@ export { parseEquation, stoichiometry, half, SHE, level } from "./equation.js";
 export { traces, speciesRole, typeset } from "./traces.js";
 export { pulse, square, triangle, ramp, injector, recombination, photogeneration } from "./sources.js";
 export { describe, unitWarnings } from "./describe.js";
+export { henderson, planck } from "./junction.js";
 export { perovskiteCell, PEROVSKITE_SCANS, hysteresis } from "./devices.js";
 export { IONS, H2O, WATER_EPSR, SEMICONDUCTORS, METALS, aqueous, semiconductor, metal } from "./data.js";

package/types/recorder.d.ts

@@ -4,15 +4,15 @@
  * neither, at the end of each `advance()` call. The trace (`t`, `current`, `voltage`, and
  * `probes` if given) runs from the start through every accepted step of every call.
  * @param {import('./index.js').Device} device
- * @param {{ every?: number, times?: number[], probes?: { x: number, species: string, quantity?: 'c' | 'V', region?: string | number }[] }} [opts]
+ * @param {{ every?: number, times?: number[], probes?: { x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number }[] }} [opts]
  */
 export function recorder(device: import("./index.js").Device, opts?: {
     every?: number;
     times?: number[];
     probes?: {
         x: number;
-        species: string;
-        quantity?: "c" | "V";
+        species?: string;
+        quantity?: "c" | "V" | "phi";
         region?: string | number;
     }[];
 }): {