driftlet 0.6.0 → 0.8.0

package/README.md

@@ -26,18 +26,18 @@ minor versions.
 ## Is it for your problem?
 
 The same equations go by different names in different fields. If your problem is one-dimensional
-(planar), it's probably here:
+(planar, or radial: spheres and cylinders, or any cross-section varying along x), it's probably here:
 
 | If you work on | you may call it | start from | checked against |
 |---|---|---|---|
 | 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, corrosion | Nernst–Planck, concentration polarization, limiting current, Butler–Volmer, Warburg, cyclic voltammetry, salt bridges and liquid junctions, mixed potentials, electrodes under a film | [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), [`ports`](test/ports.test.js) tests | `i_lim·tanh(V/4V_T)`, Butler–Volmer closed form, finite-length Warburg; junction potentials against Henderson, Planck, JPCalc and LJPcalc; Wagner–Traud |
 | 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.8.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
 
@@ -202,7 +204,9 @@ current. Supported physics:
 
 ## What it doesn't do
 
-- **More than one dimension.** Planar 1D only, so no porous-electrode (P2D) models. For 2D/3D,
+- **More than one dimension.** 1D only: planar, or a cross-section varying along x (spheres,
+  cylinders, a thinning film), so no porous electrodes with diffusion inside their particles
+  (P2D models). For 2D/3D,
   see [ChargeTransport.jl](https://github.com/WIAS-PDELib/ChargeTransport.jl), TCAD tools or
   COMSOL.
 - **Cross-diffusion.** Each species moves down its own μ̄ with its own D (the statistics can be
@@ -241,6 +245,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 |
@@ -254,6 +261,8 @@ Every physics feature is tested against analytic results (`npm test`, node's bui
 | Advection and eddy mixing | exact convection–diffusion profile; `D + D_mix`; junction EMF unchanged by mixing | 1e-12; 1e-12; 1e-5 |
 | Metal regions | ohmic; Schottky face and MOS gate equal their contact forms; Ag \| AgNO₃ \| Ag with metal electrodes; bipolar electrode at V/2 | 1e-12; 1e-9; 1e-9; 1e-9 |
 | Internal ports | transmission line σV tanh(L/λ)/λ (O(h²)); held level; MOS low-frequency C–V with a grounded channel | 1e-4; 1e-9; 2e-3 |
+| Cross-sections (spherical, cylindrical, any A(x)) | steady diffusion to a sphere and a cylinder (exact on any grid); Cottrell with the spherical term; uptake by a sphere filling from its surface; Debye–Hückel around a charged sphere, potential and charge | 1e-10; 3e-4; 2e-4; 1e-3, 3e-4 |
+| Electrodes spread through a port | transmission line with the reaction's linear kinetics as the conductance (O(h²)), rates along it; Wagner–Traud mixed potential of two Butler–Volmer couples, floating | 1e-4, 2e-3; 1e-6 V |
 | Impedance | Macdonald blocking-electrode spectrum, 100 Hz–1 GHz; finite-length Warburg (Ag \| AgNO₃ \| Ag); DC limit = differential resistance | 3e-4; 3e-5; 1e-6 |
 | Conservation | per step, and against time-integrated contact fluxes | 1e-11 relative |
 | Strictly neutral limit (ε = 0) | Planck EMF; polarization with no overlimiting; Donnan at neutral faces | 1e-5; 1e-4; 1e-9 |

package/docs/device.md

@@ -24,6 +24,7 @@ too (`FARADAY`, `GAS_CONSTANT`, `EPS0`, …).
 | `contacts` | `{ left, right }` |
 | `ports` | internal ports: outside phases exchanging with a window of nodes |
 | `grid` | default spacing for every region |
+| `geometry` | the cross-section $`A(x)`$: planar (default), spherical or cylindrical shells, or a profile (see [geometry](#geometry)) |
 
 ## Species
 
@@ -98,7 +99,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 +171,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 +229,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`$
@@ -395,7 +446,16 @@ contact: held at a voltage, behind a resistance, or driven by a current (a refer
 is a port at `I: 0`). Each solution reports `ports[k]`, with `{ name, V, flux, current }`: what
 the port brings into the device.
 
-A held (`'equilibrium'`) level leaves the device's two end nodes to their contacts.
+A held (`'equilibrium'`) level leaves the device's two end nodes to their contacts. A port that
+exchanges only neutral species carries no current, so its voltage means nothing: give it no drive.
+
+An exchange link's source is linear in $`\mu_{out} - \mu`$, so it grows without bound as the
+species runs out ($`\ln c`$). A supply limited by diffusion through a film above the window, such as O₂
+reaching a thin layer of water from the air, is linear in $`c`$ instead: $`k(c_{sat} - c)`$. For that,
+use a [bulk reaction](#bulk-reactions) with the outside phase as a fixed participant, e.g.
+`{ equation: 'Air = O2', fixed: { Air: muSat }, kf: { water: profile } }`. Its rate is
+$`k_f (1 - c/c_{sat})`$, and a profile gives $`k_f`$ its spatial variation (a film of thickness $`h(x)`$:
+$`D c_{sat}/h^2`$).
 
 A port driven by a current (`I`, or a waveform) floats to whatever voltage delivers it: with a
 conductance `G` per volume over a window of width $`w`$, it sits about $`I/(G w)`$ above the
@@ -417,6 +477,44 @@ steady state can be computed there. A port holding the electrons beside the oxid
 channel's potential anchors it, as source and drain would, and the device then shows the
 low-frequency C–V.
 
+### Electrodes spread through a window
+
+A port can also hold an electrode: a metal whose carrier sits at the port's level, reacting all
+through the window rather than at one face. That's the floor under a thin film of electrolyte, the
+walls of a crevice or a pit, or the matrix of a porous electrode, wherever the metal conducts well
+enough to be one level. Give the port its `reactions` (Butler–Volmer, as at a face), the carrier as
+its `terminal` (the species need be in no material), and the electrode's `area` per volume of the
+window:
+
+```js nocheck
+ports: [{
+  name: 'iron', region: 'film', terminal: 'e-', V: 0,
+  area: 1 / 100e-6,           // m²/m³: a film 100 µm thick on the metal; or a profile against x
+  reactions: [
+    { equation: 'Fe2+ + 2 e- = Fe(s)', fixed: { 'Fe(s)': 0 }, k0: 5e-6, alpha: 0.5 },
+    { equation: 'O2 + 2 H2O + 4 e- = 4 OH-', fixed: { H2O: -237.13e3 }, k0: 3e-9, alpha: 0.125 },
+  ],
+}]
+```
+
+Each node's rate per area is the face's law, with the region's species at that node and the
+carrier at activity 1 and level $`V`$. Times the area per volume, it makes and consumes the
+region's species there, and the electrons it takes or gives are the port's current. The port is
+a terminal like any other. Held at a voltage, it's a potentiostat. At `I: 0` (or with nothing
+else to carry current), the reactions settle at the mixed potential, the corrosion potential where
+anodic and cathodic currents cancel over the window, while each node can be a net anode or a net
+cathode. A floating one starts there, for the start's composition. Each solution reports the
+window's nodes and every reaction's rate at each, `ports[k].x` and `ports[k].rates`
+(mol/(m²·s) of electrode, forward), with `ports[k].area`.
+
+Validated against the transmission line (linear kinetics along a bar, test/ports.test.js) and the
+Wagner–Traud mixed potential of two Butler–Volmer couples. In 1D, a film on a metal is a slice
+along the metal: the film's thickness enters through `area`, and through a bulk reaction for
+anything that reaches the film from above (O₂ from the air, see the exchange link above). Where
+the film's thickness varies, give the device its [cross-section](#geometry) too, so that ions
+travelling along the film squeeze through where it thins: for a drop on a metal, seen from its
+centre, $`A = 2\pi r\,h(r)`$ with `area` $`1/h(r)`$.
+
 ## Terminals
 
 The two contacts and every port are the device's terminals, named `left`, `right` and by each
@@ -471,6 +569,34 @@ cells exceeds the limiting current by 1.4% at 0.5 V, while `{ hmin: 10e-9, hmax:
 within 0.1% with as many nodes. Where a species carrying the current is steep across a region's
 end cells in this way, the solution's `warnings` say so, with a rough estimate of the excess.
 
+## Geometry
+
+A device is planar unless it says otherwise: a slab whose cross-section $`A`$ is 1 m², so every
+current, flux, amount and charge reads per m². With `geometry`, the cross-section varies along x,
+and the conservation laws hold for totals through it: a box holds $`\int A\,dx`$, and what crosses
+a face is the flux there times $`A`$ there.
+
+```js nocheck
+geometry: { type: 'spherical', r0: 10e-6 },   // shells, r = r0 + x: a microelectrode of radius r0
+geometry: { type: 'cylindrical', r0: 0 },     // a wire or fibre from its axis (per metre of length)
+geometry: { area: { x: [0, 1e-3], values: [3e-6, 1e-7] } }, // A (m²) against x: a film thinning, a pit
+```
+
+This is how radial problems become 1D, with the right $`1/r^2`$ (or $`1/r`$) in every divergence and in
+Gauss's law, without writing them out. The finite volumes integrate over shells, so conservation
+is exact as in a slab. Each segment's transport is weighted by its length over $`\int dx/A`$, which
+makes steady diffusion between two nodes exact for any $`A(x)`$ (the $`1/r`$ and $`\ln r`$ profiles
+on any grid). Where $`A`$ vanishes at an end (a sphere's centre, `r0: 0`), the segment takes $`A`$ at
+its middle, and nothing passes the end. Only an end may have $`A = 0`$. Flow (`velocity`) is for
+planar devices.
+
+With a cross-section, the solution's currents, contact and port fluxes, terminal currents and
+`charge` are totals (A, mol/s; per metre for cylinders), and so are `I` drives. Face laws,
+rates, `interfaces[f].N` and `D`, and concentrations stay per area or per volume. Validated against
+steady diffusion to a sphere and a cylinder (exact), Cottrell's transient with the spherical term,
+uptake by a sphere filling from its surface, and Debye–Hückel screening around a charged sphere
+(test/geometry.test.js).
+
 ## Using a device
 
 ```js nocheck
@@ -500,11 +626,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
@@ -558,14 +686,14 @@ console.log(`${run.steps} steps; I(0.01 s) ≈ ${run.trace.current[run.trace.t.f
 | `phi` | bookkeeping $`\phi`$, V (`NaN` where undefined) |
 | `c[name]`, `mu[name]`, `muStd[name]` | concentration, $`\bar\mu`$, standard level $`\mu^\circ + zF\phi`$ (`NaN` where absent) |
 | `V[name]`, `Vstd[name]` | species voltage $`\bar\mu/(zF)`$ and standard level as a voltage (charged species) |
-| `current`, `terminalVoltage` | current toward +x through the device (A/m²) and $`V_{\mathrm{right}} - V_{\mathrm{left}}`$ |
+| `current`, `terminalVoltage` | current toward +x through the device (A/m², or A through a [cross-section](#geometry)) and $`V_{\mathrm{right}} - V_{\mathrm{left}}`$ |
 | `terminals[name]` | `{ V, current }` for each terminal (contacts and ports), current into the device |
 | `contacts.left/right` | `{ V, flux: {name}, D, current }` at each contact |
 | `gates.left/right` | charge on a gate or Stern plate, where the contact is capacitive |
 | `ports[k]` | `{ name, V, flux: {name}, current }`: what each internal port brings into the device |
 | `interfaces[f]` | `{ left, right, dipole, sheetCharge, D, N: {name}, rates }`: the names of the regions the face joins, what crosses it by its links, and each face reaction's rate (mol/(m²·s)) |
 | `bulkReactions[k]` | `{ rate, regions, total }`: each bulk reaction's forward rate at every node (mol/(m³·s), `NaN` where it doesn't run), and integrated over each region and the device (mol/(m²·s)), as the balances count it: a charge-balance check is J = F(generation − recombination), which the kit's `check()` does for every species |
-| `charge` | total charge in the device, C/m² |
+| `charge` | total charge in the device, C/m² (C through a cross-section) |
 | `conservation` | per species stretch: amount, reference, intake through contacts, drift |
 | `warnings` | e.g. unresolved double layers, conventions a statistics model relies on, and for a failed solve, where the system is nearly singular |
 | `converged`, `iterations`, `steps`, `substeps`, `history`, `time` | solver bookkeeping |

package/docs/kit.md

@@ -82,7 +82,7 @@ $`\mu_{\mathrm{H_2}} = 0`$, so its standard level is $`\phi + \mu^\circ_{\mathrm
 
 ```js
 import { Device } from 'driftlet';
-import { build, layer, ohmic, half, level } from 'driftlet/kit';
+import { build, layer, ohmic, half, level, polarization } from 'driftlet/kit';
 
 const silver = half('Ag+ + e- = Ag(s)', { 'Ag(s)': 0 });
 const stern = { phi: { type: 'capacitive', C: 0.2 }, zeroCharge: 0.1 }; // an assumed pzc
@@ -108,11 +108,35 @@ const def = build({
   grid: { hmin: 0.1e-9, hmax: 100e-9, ratio: 1.15 },
 });
 console.log(JSON.stringify(def.interfaces[0].reactions[0])); // { left: { e-: -1, Ag(s): 1 }, right: { Ag+: -1 }, … }
-const sol = new Device(def).solve();
+const dev = new Device(def), sol = dev.solve();
 const redox = level(sol, silver); // V_Ag⁺(x) in the solution
 console.log(`redox level at mid-cell: ${redox[sol.x.length >> 1].toFixed(4)} V`);
+// The left electrode's polarization curve, 0.2 V either side of its own level (see below).
+const metalSide = sol.V['e-'][0];
+const curve = polarization(dev, sol, { face: 0 }, Array.from({ length: 81 }, (_, j) => metalSide - 0.2 + j * 0.005));
+console.log(curve.reactions[0].level, curve.current[40]); // the couple's level here, and the current at the metal's own
 ```
 
+### Polarization curves: an Evans diagram
+
+`polarization(device, sol, where, V)` evaluates every electrode reaction at one spot with the
+solution beside it held as `sol` has it and the metal's level set to each `V` (an electron
+voltage, the terminals' convention). It works at a face (`{ face: f }`, the face's metal side) or
+at a spot of an [electrode port](device.md#electrodes-spread-through-a-window)
+(`{ port: name, x }`). Each reaction comes back with its rate (mol/(m²·s), forward), its partial
+current (A/m², anodic positive: into the solution) and its `level`, where the rate vanishes (the
+couple's redox level there, as `level()` gives it). The net current is their sum. Plotting
+log|current| against V gives the Evans diagram. The net crosses zero at the spot's open-circuit
+potential, between the couples' levels, and the metal's actual level is where the solve put it.
+The law is the solver's own, so at that level the rates are the solution's. Against SHE, subtract
+the SHE level (`sol.phi` with the usual tables' ions).
+
+The example above ends with the left electrode's curve.
+
+Concentrations are held, so these are the curves of that instant (for a mixed potential, the
+kinetic picture). Away from the actual level the composition beside the electrode would change,
+which is the transport the full solve accounts for.
+
 ## Sources
 
 Helpers that write sources as plain data:
@@ -169,6 +193,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 +391,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 +427,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/docs/numerics.md

@@ -117,6 +117,22 @@ Grids grade geometrically from `hmin` at each region end up to `hmax`. They're n
 automatically, to avoid performance surprises. Instead, solutions warn when a double layer the
 model is meant to resolve is coarser than the local Debye length.
 
+### A cross-section
+
+With a [`geometry`](device.md#geometry), the device has a cross-section $`A(x)`$ (spherical
+shells $`4\pi r^2`$, cylindrical $`2\pi r`$ with $`r = r_0 + x`$, or a profile), and every balance
+is for totals through it:
+$`\partial_t (A c_i) + \partial_x (A N_i) = A \sum_r \nu_{ir} r_r`$, and Gauss's law
+$`-\partial_x (A\varepsilon\,\partial_x\phi) = A\rho`$. The box method carries this without writing out any
+$`1/r`$ terms: a box's volume becomes $`\int A\,dx`$ over it (exactly, for each shape), and what a
+segment, a face or a contact passes is multiplied by the area it passes through. A segment's
+$`1/h`$ becomes $`1/\int dx/A`$ over it, its resistance per unit conductivity, which is the exact
+weighting for steady diffusion (a constant total flux $`AN`$, so $`\Delta c = AN\int dx/A\,/D`$).
+Scharfetter–Gummel keeps its form with that weighting, and so does the displacement. Where $`A`$
+vanishes at an end (a sphere's centre), $`\int dx/A`$ diverges, so that segment takes $`A`$ at its
+middle. A flux node's unknowns stay per area, entering each side's balance times the face's
+area. A planar device has $`A = 1`$ and every factor is exactly 1, so it's unchanged to the last bit.
+
 ### What lives where
 
 | Place | Holds |

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.8.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.8.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.8.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), `polarization` (an electrode's reactions at hypothetical metal levels, with the solution held: an Evans diagram), `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.8.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.8.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.8.0/src/plot.js';
 
 const def = build({
   T: 300,
@@ -351,11 +405,16 @@ has the long form):
   do. It checks the setup: a solver's output looks authoritative even when an input is wrong, and
   a mismatch is the cheapest way to catch it. Where the two should differ (high injection, a
   finite pulse), say why.
-- **Stay honestly inside 1D.** driftlet models planar devices. Where the real device isn't one,
+- **Stay honestly inside 1D.** driftlet models devices along one coordinate: planar, or with a
+  cross-section A(x) (`geometry`: spherical or cylindrical shells, or a profile), in which case
+  currents and fluxes are totals through it. Where the real device isn't one,
   say so and pick the slice that still tells the true story: a MOSFET's gate stack, read as the
   MOS capacitor its channel sits on (pinch-off along the channel is 2D); a BJT along its
   emitter–base–collector axis; one particle of a porous battery electrode, or a thin dense film,
-  rather than the whole porous electrode (that's a P2D model).
+  rather than the whole porous electrode with diffusion inside its particles (that's a P2D model).
+  A metal that reacts all along a film of electrolyte (corroding iron under a drop, a crevice's
+  walls, a well-conducting porous matrix) is a port with `reactions` and an `area` per volume:
+  an electrode spread through a window, not a face at each end.
 - **Check `sol.converged` and `sol.warnings`** on every solve, and pin the CDN version you
   tested against.
 
@@ -384,11 +443,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.8.0",
   "description": "Small, dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for interactive web demos",
   "type": "module",
   "exports": {