driftlet 0.11.4 → 0.12.0

package/README.md

@@ -44,7 +44,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.11.4/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@0.12.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).
 
@@ -141,6 +141,8 @@ them locally, serve the repository root (e.g. `python3 -m http.server`) and open
 | **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 |
+| [![action potential](demos/screenshots/axon.png)](https://markblundeberg.github.io/driftlet/demos/axon.html) | [![propagation](demos/screenshots/propagation.png)](https://markblundeberg.github.io/driftlet/demos/propagation.html) | [![myelin](demos/screenshots/myelin.png)](https://markblundeberg.github.io/driftlet/demos/myelin.html) |
+| **Action potential**: Hodgkin and Huxley's gated channels, each ion's driving force through the spike, against the HH equations | **Propagation**: a spike travelling along an axon at HH's speed, out of the ions' drift; which ions carry it | **Myelin**: saltatory conduction, node to node, against a compartmental cable; a race with a bare axon |
 
 ## Is it for your problem?
 
@@ -156,7 +158,7 @@ The same equations go by different names in different fields. If your problem is
 | 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, 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 |
+| 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), [action-potential](https://markblundeberg.github.io/driftlet/demos/axon.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); voltage-gated channels with Hodgkin–Huxley kinetics, action potentials, and their propagation along an axon ([`gates`](test/gates.test.js), [`cable`](test/cable.test.js) tests) | GHK potential and current–voltage curve; a resolved lipid layer; Mullins–Noda; the pump's static head; Donnan; HH gating under voltage clamp; the space-clamped HH equations |
 
 The tests are worked setups, each with its analytic check, so they double as recipes. The
 [validation table](#validation) lists them all.
@@ -255,6 +257,8 @@ Every physics feature is tested against analytic results (`npm test`, node's bui
 | 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 |
+| Voltage-gated channels (Hodgkin–Huxley gates on a membrane face) | each gate at α/(α + β) under a voltage clamp, and relaxing at α + β after a step; a squid axon's action potential against the space-clamped HH equations with GHK currents; its impedance at rest (inductive, resonant) against the linearised equations | 1e-12; 2e-4; 1 mV; 5e-4 |
+| A propagating action potential (a squid axon along x: gated membrane port, ions drifting in the axoplasm) | rest at HH's −65 mV and gate values; conduction velocity against the cable equation solved directly, and HH's 18.8 m/s; a myelinated axon's saltatory conduction, node by node, against a compartmental cable | 0.01 mV, 1e-4; 2e-3; 1%; 1 µs of ~25 per node |
 | 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 |

package/docs/device.md

@@ -277,6 +277,68 @@ read from `sol.phi` (or a `'phi'` probe in a transient). A bath contact's termin
 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.
 
+### Voltage-gated channels
+
+A permeability can be gated, as Hodgkin and Huxley's Na⁺ and K⁺ channels are: the face lists its
+`gates`, each a fraction $`x`$ in [0, 1] with first-order kinetics in the voltage across the face,
+$`V = \phi_{\mathrm{right}} - \phi_{\mathrm{left}}`$ at its two edge nodes,
+
+```math
+\frac{dx}{dt} = \alpha(V)\,(1 - x) - \beta(V)\,x ,
+```
+
+and a link names the gates that scale its $`P`$ (or a conductance link's $`G`$), with their exponents:
+$`P\,m^3 h`$ for `{ m: 3, h: 1 }`. (A membrane along a region instead, an axon's, is a
+[port](#a-membrane-through-a-window-gated-channels).)
+Each of $`\alpha`$ and $`\beta`$ is one of NeuroML's three standard forms, with `rate` in 1/s and `midpoint`
+and `scale` in volts:
+
+| `type` | rate |
+| --- | --- |
+| `'exp'` | $`\mathtt{rate}\; e^{(V - \mathtt{midpoint})/\mathtt{scale}}`$ |
+| `'sigmoid'` | $`\mathtt{rate} / (1 + e^{(\mathtt{midpoint} - V)/\mathtt{scale}})`$ |
+| `'expLinear'` | $`\mathtt{rate}\; y/(1 - e^{-y})`$, $`y = (V - \mathtt{midpoint})/\mathtt{scale}`$ |
+
+With the outside on the left, $`V`$ is the membrane potential $`\phi_{\mathrm{in}} - \phi_{\mathrm{out}}`$. Hodgkin and
+Huxley's squid axon (at their 6.3 °C):
+
+```js nocheck
+{
+  phi: { type: 'capacitive', C: 0.01 },
+  gates: {
+    m: { alpha: { type: 'expLinear', rate: 1000, midpoint: -0.040, scale: 0.010 }, beta: { type: 'exp', rate: 4000, midpoint: -0.065, scale: -0.018 } },
+    h: { alpha: { type: 'exp', rate: 70, midpoint: -0.065, scale: -0.020 }, beta: { type: 'sigmoid', rate: 1000, midpoint: -0.035, scale: 0.010 } },
+    n: { alpha: { type: 'expLinear', rate: 100, midpoint: -0.055, scale: 0.010 }, beta: { type: 'exp', rate: 125, midpoint: -0.065, scale: -0.080 } },
+  },
+  species: {
+    'Na+': { type: 'permeability', P: 1.16e-6, gates: { m: 3, h: 1 } },
+    'K+': { type: 'permeability', P: 1.33e-6, gates: { n: 4 } },
+    'Cl-': { type: 'permeability', P: 6.4e-9 }, // the leak
+    'A-': 'blocked',
+  },
+}
+```
+
+The gates scale permeabilities and nothing else: they hold no charge (the small gating current
+of the channels' voltage sensors is left out, as Hodgkin and Huxley left it out), and each ion
+still crosses by electrodiffusion down its own $`\bar\mu`$, so the dissipation stays positive whatever
+they do. In steady state each gate is at $`\alpha/(\alpha + \beta)`$; each solution reports them as
+`interfaces[f].gates` (`{ m, h, n }`) with the voltage they follow, `interfaces[f].V`.
+
+Two things differ from the textbook equations. The currents are GHK's, which rectify: a channel's
+conductance depends on the voltage, so a permeability matches a conductance $`g`$ at one voltage
+only (above, the chord conductances at rest, −65 mV, for Hodgkin and Huxley's 120, 36 and 0.3
+mS/cm²; matched at the reversal potentials instead, the rest depolarises itself and the axon
+fires on its own). And a cell without a pump has no resting steady state: `solve()` finds its
+Donnan equilibrium, every permeant ion level across the membrane, which the real cell reaches
+only over hours. Start a transient from the concentrations given (it settles to rest within
+milliseconds), or keep the gradients with the Na⁺/K⁺ pump on the same face. Started from the
+same state, a squid axon's action potential follows the space-clamped Hodgkin–Huxley equations
+with GHK currents to within 1 mV; and in small signals, with the membrane held at rest between
+two baths, `impedance()` gives the gates' inductance that Cole measured (the impedance inductive
+below ~50 Hz and resonant near 60 Hz), the linearised equations' to 5e-4
+([`gates`](../test/gates.test.js) test).
+
 ### 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`$
@@ -432,6 +494,7 @@ any combination:
 | `reactions`, `area` | an [electrode spread through the window](#electrodes-spread-through-a-window) | a thin film on a metal, a crevice, a porous electrode |
 | `surface` | [species on that electrode's sites](#an-electrodes-surface-adsorbates-and-passive-films) | adsorbates, a passive film |
 | `capacitance`, `area` | [charge held across a capacitance](#a-capacitance-through-a-window) | a gate along a channel, a double layer |
+| `gates` | [voltage-gated channels](#a-membrane-through-a-window-gated-channels) on its conductance links | an axon's membrane along it |
 
 ```js nocheck
 ports: [{
@@ -618,6 +681,44 @@ below threshold through saturation (second order in the grid); a porous electrod
 impedance $`\sqrt{r/y}\coth(L\sqrt{ry})`$, the double layer in series with the ions' chemical
 capacitance; and the gate's low-frequency impedance against $`dQ/dV_G`$ from steady states.
 
+### A membrane through a window: gated channels
+
+A port with a capacitance can carry [gates](#voltage-gated-channels), as a face can: at each node of
+its window, each gate is a fraction open with Hodgkin–Huxley kinetics in the voltage across the
+port's capacitance there, $`V_m = \phi - (V - \mathtt{zeroCharge})`$, and its conductance links name
+the gates that scale them (`G × m³h`). That's a membrane all along a region, between it and an
+outside held by the port: an axon's, with x running along the axon. Per volume of axoplasm, a
+cylinder of radius a has $`2/a`$ of membrane (`area`); held at `V: 0` with `zeroCharge: 0`, the port's
+V is the outside's $`\phi`$, and a charged species' `offset` is its level there against that,
+$`(\mu^\circ + RT\ln(c_{out}/c_{\mathrm{ref}}))/(zF)`$. A conductance link's current is then
+$`G\,(V_{i,out} - V_i)`$, which is $`g\,a_m (E_i - V_m)`$: Hodgkin and Huxley's linear channel, with $`E_i`$ the
+Nernst potential at the inside's concentration there.
+
+```js nocheck
+ports: [{
+  name: 'membrane', region: 'axon', V: 0, terminal: 'K+', area: 2 / 238e-6, // a squid giant axon
+  capacitance: { C: 0.01, zeroCharge: 0 },
+  gates: hodgkinHuxley({ /* … */ T }).gates,
+  species: {
+    'Na+': { type: 'conductance', G: 1200 * 2 / 238e-6, offset: offsetNa, gates: { m: 3, h: 1 } },
+    'K+': { type: 'conductance', G: 360 * 2 / 238e-6, offset: offsetK, gates: { n: 4 } },
+    'Cl-': { type: 'conductance', G: 3 * 2 / 238e-6, offset: offsetCl }, // the leak
+  },
+}]
+```
+
+With the axoplasm strictly neutral and the outside held (no resistance outside), the ions'
+drift along x and the membrane's charging are cable theory, without its being put in: a squid
+axon's action potential propagates at Hodgkin and Huxley's speed, 18.73 m/s for their 18.5 °C
+axon (they computed 18.8 by hand), the cable equation's own to 2e-3
+([`cable`](../test/cable.test.js) test). A myelinated axon is regions of one axoplasm, each node
+of Ranvier and each internode its own, with a port each: the nodes' gated, the internodes' a small
+capacitance (myelin) and nothing else. The grid refines at every node's faces, and the spike jumps
+node to node, arriving at each within 1 µs of a compartmental cable's prediction (the same test).
+Each solution's `ports[k]` reports the gates at each node of the window, `gates[name][j]`,
+and the voltage they follow, `Vm[j]`. A gated window can't overlap another port's gated or
+surfaced one.
+
 ### What a solution reports
 
 Each solution's `ports[k]`, as the port has them:
@@ -630,6 +731,7 @@ Each solution's `ports[k]`, as the port has them:
 | `rates[q][j]` | reaction q's forward rate at node j, mol/(m²·s) of electrode (reaction first, then node) |
 | `coverage[name][j]`, `bare[j]` | with a surface: each species' coverage θ, and the bare fraction θ₀ to full precision |
 | `sigma[j]`, `charge` | with a capacitance: σ per area of electrode (C/m²), and the total the port's side holds |
+| `gates[name][j]`, `Vm[j]` | with gates: each gate's fraction open, and the voltage across the capacitance that they follow (V) |
 
 The arrays are typed (`Float64Array`), so `Array.from` them before mapping to anything but
 numbers. The kit's [`polarization()`](kit.md#polarization-curves-an-evans-diagram) gives each reaction's rate at a spot of the
@@ -762,7 +864,9 @@ const now = dev.solution();                   // snapshot of the current state
   `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
+  nodes around `x` (at an interface, `region` picks the side). That's what a detector at `x` sees.
+  At a face, `{ interface: f, species }` reads a species' flux through it (mol/(m²·s), toward +x,
+  as `interfaces[f].N`), and `{ interface: f, gate }` a gate's fraction open. 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

@@ -142,6 +142,18 @@ Concentrations are held, so these are the curves of that instant (for a mixed po
 kinetic picture). Away from the actual level the composition beside the electrode would change,
 which is the transport the full solve accounts for.
 
+## Channels
+
+**`hodgkinHuxley({ inside, outside, T, g, leak, leakZ, at, names })`**: Hodgkin and Huxley's
+squid-axon channels for a [membrane face](device.md#voltage-gated-channels) with the outside on its
+left: `{ gates, species }`, the face's `gates` (m, h and n, their 1952 rates at 6.3 °C scaled to
+`T` by Q₁₀ = 3) and links for Na⁺ (P·m³h), K⁺ (P·n⁴) and the leak (one ion, `leak`, of charge
+`leakZ`: Cl⁻ by default). The currents are GHK's, which rectify, so each permeability is the one
+whose chord conductance at `at` (−65 mV) is HH's `g` (120, 36 and 0.3 mS/cm²) at the
+concentrations given. Spread it into the face beside its $`\phi`$ law, adding the other species'
+links: `{ phi: { type: 'capacitive', C: 0.01 }, gates: hh.gates, species: { ...hh.species, 'A-': 'blocked' } }`.
+`ghkCurrent(z, inside, outside, V, T)` is the GHK current (outward, A/m²) at unit permeability.
+
 ## Sources
 
 Helpers that write sources as plain data:

package/docs/numerics.md

@@ -210,9 +210,16 @@ flux node's own rows are the interface laws:
 | species, blocked or absent on one side | $`N_f = 0`$ |
 | species, conductance | $`N_f - G V_T (\eta_L - \eta_R)/(z^2 F) = 0`$ |
 | face reaction $`k`$ | $`r_k - \mathrm{rate}_k(\mathrm{state}_L, \mathrm{state}_R) = 0`$, and each participant's edge node takes $`\nu \cdot r_k`$ |
+| gate $`q`$ | $`(x_q - x_q^{\mathrm{old}})/dt - \alpha(V)(1 - x_q) + \beta(V)\,x_q = 0`$, $`V = V_T(\hat\phi_R - \hat\phi_L)`$; a gated permeability's $`P`$ takes $`\prod x^p`$ |
 
 Every row couples only neighbours, with no penalty terms. A face reaction's rate is an unknown
-of the face block, so the two edge nodes it couples meet only through the block between them.
+of the face block, so the two edge nodes it couples meet only through the block between them;
+so is a gate's fraction open, its row coupling it to the two edge nodes' $`\hat\phi`$, and the gated
+fluxes to it, all within the face's block and its neighbours'. Newton's convergence and the time
+step's error count a gate's change as they count a potential's in thermal units (1e-3 of $`m`$ is
+0.3% of $`m^3`$), and a gate is evaluated in [0, 1] where Newton's iterates stray past its ends. A
+membrane port's gates are unknowns of each window node's block, after its surface's coverages,
+with the same row in the voltage across the port's capacitance there.
 A species can take part in a reaction at a face and also cross it by a link (its flux slot)
 at the same time; where it exists on both sides, that link must be given explicitly. A continuity
 row has a zero diagonal block, but block Thomas still sees a non-singular block there once 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.11.4/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.11.4/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.11.4/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`.
@@ -210,8 +210,50 @@ console.log(check(dev, sol).text); // per compartment: Na⁺ leaks into the cyto
 ```
 
 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.
+current), V_m is GHK. Without the pump, a closed cell runs down to Donnan equilibrium.
+
+## Template: an action potential
+
+Voltage-gated channels: a face's `gates` (each a fraction open with Hodgkin–Huxley kinetics,
+dx/dt = α(V)(1 − x) − β(V)x, in V = φ_right − φ_left), and a permeability scaled by them
+(`gates: { m: 3, h: 1 }`). `hodgkinHuxley()` in the kit writes the squid axon's: its gates, and
+GHK permeabilities matched to HH's conductances at rest. A pump-less cell has no steady rest
+(`solve()` finds Donnan), so start the transient from the concentrations given: the membrane
+settles within milliseconds.
+
+```js
+import { Device } from 'driftlet';
+import { build, layer, bath, aqueous, injector, pulse, hodgkinHuxley } from 'driftlet/kit';
+
+const T = 279.45; // HH's 6.3 °C
+const out = { 'Na+': 440, 'K+': 20, 'Cl-': 450, 'A-': 10 }, inside = { 'Na+': 50, 'K+': 400, 'Cl-': 52, 'A-': 398 }; // squid, mM
+const water = aqueous(['Na+', 'K+', 'Cl-'], { epsr: 0 });
+water.species.push({ name: 'A-', z: -1, cRef: 1000 });
+water.materials.water.species['A-'] = { D: 0.5e-9, mu0: 0 };
+const hh = hodgkinHuxley({ inside, outside: out, T }); // outside on the left
+const axon = new Device(
+  build({
+    T,
+    library: [water],
+    stack: [
+      bath(out, 'Cl-'),
+      layer('water', 5e-6, { name: 'outside', c0: out }),
+      { phi: { type: 'capacitive', C: 0.01 }, gates: hh.gates, species: { ...hh.species, 'A-': 'blocked' } },
+      layer('water', 20e-6, { name: 'cytoplasm', c0: inside }),
+      { species: { 'Na+': 'blocked', 'K+': 'blocked', 'Cl-': 'blocked', 'A-': 'blocked' }, phi: 'neutral' },
+    ],
+    // the stimulus: 10 µA/cm² of K⁺ for 1 ms at 20 ms, from a pipette in the cytoplasm
+    ports: [injector({ region: 'cytoplasm', from: 15e-6, to: 20e-6, species: 'K+', I: pulse({ start: 20e-3, width: 1e-3, amplitude: 0.1 }) })],
+    grid: { hmin: 50e-9, hmax: 1e-6 },
+  }),
+);
+let peak = -1;
+for (let k = 1; k <= 300; k++) {
+  const sol = axon.advance(k * 1e-4); // 0.1 ms at a time
+  peak = Math.max(peak, sol.interfaces[0].V); // V_m, and sol.interfaces[0].gates = { m, h, n }
+}
+console.log(`peak ${(peak * 1e3).toFixed(1)} mV`); // ~ +12 mV: GHK's Na⁺ current is limited by the 50 mM inside
+```
 
 ## Template: an electrode in a stirred solution
 
@@ -423,9 +465,9 @@ solve), as long as it settles rather than ping-pongs.
 <span id="readout"></span>
 <div id="figure"></div>
 <script type="module">
-import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.11.4/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.11.4/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.11.4/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@0.12.0/src/plot.js';
 
 const def = build({
   T: 300,

package/package.json

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

package/src/channels.js

@@ -0,0 +1,73 @@
+// driftlet/kit: voltage-gated channels as plain definition data. Hodgkin and Huxley's squid axon:
+// its gates, and permeabilities for its Na⁺, K⁺ and leak channels, for a membrane face.
+
+import { DeviceError } from './errors.js';
+import { FARADAY, GAS_CONSTANT } from './constants.js';
+
+const fail = (message) => {
+  throw new DeviceError(message);
+};
+const need = (ok, message) => ok || fail(message);
+const num = (v) => typeof v === 'number' && Number.isFinite(v);
+
+// Hodgkin and Huxley (1952), J. Physiol. 117, 500, at their 6.3 °C, in the modern convention
+// (V = φ_in − φ_out, rest at −65 mV), in SI: rates in 1/s, voltages in V.
+const mV = 1e-3;
+const HH_GATES = {
+  m: { alpha: { type: 'expLinear', rate: 1000, midpoint: -40 * mV, scale: 10 * mV }, beta: { type: 'exp', rate: 4000, midpoint: -65 * mV, scale: -18 * mV } },
+  h: { alpha: { type: 'exp', rate: 70, midpoint: -65 * mV, scale: -20 * mV }, beta: { type: 'sigmoid', rate: 1000, midpoint: -35 * mV, scale: 10 * mV } },
+  n: { alpha: { type: 'expLinear', rate: 100, midpoint: -55 * mV, scale: 10 * mV }, beta: { type: 'exp', rate: 125, midpoint: -65 * mV, scale: -80 * mV } },
+};
+const HH_T = 273.15 + 6.3;
+
+// The GHK current (outward, A/m²) of an ion at unit permeability, at voltage V (inside − outside).
+export function ghkCurrent(z, inside, outside, V, T) {
+  const u = (z * V * FARADAY) / (GAS_CONSTANT * T);
+  if (Math.abs(u) < 1e-9) return z * FARADAY * (inside - outside);
+  return (z * FARADAY * u * (inside - outside * Math.exp(-u))) / -Math.expm1(-u);
+}
+
+/**
+ * Hodgkin and Huxley's squid-axon channels, for a membrane face with the outside on its left
+ * (so the gates' voltage, φ_right − φ_left, is the membrane potential): the face's `gates`, and
+ * `species` links for Na⁺ (P·m³h), K⁺ (P·n⁴) and the leak (ungated), to spread into the face
+ * beside its φ law, `{ phi: { type: 'capacitive', C: 0.01 }, ...hh }`, adding links (or blocks)
+ * for any other species.
+ *
+ * The currents are GHK's, which rectify, so a permeability matches a conductance at one voltage
+ * only: each is the one whose chord conductance at `at` (rest, −65 mV) is Hodgkin and Huxley's
+ * (`g`: 120, 36 and 0.3 mS/cm²), at the concentrations given. The leak is carried by one ion
+ * (`leak`, of charge `leakZ`: Cl⁻ by default, whose Nernst level in squid is near their leak
+ * reversal, −54 mV). The
+ * rates are theirs at 6.3 °C, scaled to `T` by Q₁₀ = 3.
+ * @param {{ inside: object, outside: object, T?: number, g?: { Na?: number, K?: number, leak?: number },
+ *   leak?: string, leakZ?: number, at?: number, names?: { Na?: string, K?: string } }} opts concentrations in
+ *   mol/m³ by species name, K, S/m², V
+ * @returns {{ gates: object, species: object }}
+ */
+export function hodgkinHuxley({ inside, outside, T = HH_T, g = {}, leak = 'Cl-', leakZ = -1, at = -65 * mV, names = {} } = {}) {
+  need(inside && outside && typeof inside === 'object' && typeof outside === 'object', 'hodgkinHuxley: give inside and outside concentrations (mol/m³) by species name');
+  need(num(T) && T > 0, `hodgkinHuxley: T must be a temperature in K, got ${T}`);
+  need(num(at), `hodgkinHuxley: at must be a voltage (V), got ${at}`);
+  const G = { Na: 1200, K: 360, leak: 3, ...g };
+  const Na = names.Na ?? 'Na+', K = names.K ?? 'K+';
+  const q10 = Math.exp(Math.log(3) * ((T - HH_T) / 10)); // Q₁₀ = 3
+  const scaled = (r) => ({ ...r, rate: r.rate * q10 });
+  const gates = Object.fromEntries(Object.entries(HH_GATES).map(([k, gt]) => [k, { alpha: scaled(gt.alpha), beta: scaled(gt.beta) }]));
+  const P = (name, z, gval, what) => {
+    need(num(inside[name]) && inside[name] > 0 && num(outside[name]) && outside[name] > 0, `hodgkinHuxley: give ${name}'s concentration inside and outside (mol/m³), for its ${what}`);
+    need(num(gval) && gval > 0, `hodgkinHuxley: g.${what} must be a conductance > 0 (S/m²), got ${gval}`);
+    const E = ((GAS_CONSTANT * T) / (z * FARADAY)) * Math.log(outside[name] / inside[name]);
+    need(Math.abs(at - E) > 1e-4, `hodgkinHuxley: ${name}'s Nernst level, ${(E * 1e3).toFixed(1)} mV, is at the calibration voltage; choose another 'at'`);
+    return (gval * (at - E)) / ghkCurrent(z, inside[name], outside[name], at, T);
+  };
+  need(Number.isInteger(leakZ) && leakZ !== 0, `hodgkinHuxley: leakZ must be the leak ion's charge number, got ${leakZ}`);
+  return {
+    gates,
+    species: {
+      [Na]: { type: 'permeability', P: P(Na, 1, G.Na, 'Na channels'), gates: { m: 3, h: 1 } },
+      [K]: { type: 'permeability', P: P(K, 1, G.K, 'K channels'), gates: { n: 4 } },
+      [leak]: { type: 'permeability', P: P(leak, leakZ, G.leak, 'leak') },
+    },
+  };
+}

package/src/describe.js

@@ -201,10 +201,12 @@ export function describe(def) {
       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²`] : [];
+        const gated = (l.gates ?? []).map(([q, p]) => itf.gates[q].name + (p > 1 ? `^${p}` : '')).join('·');
+        return l.type === 'permeability' ? [`${sp.name} ${num(l.P)} m/s${gated ? ` × ${gated}` : ''}`] : l.type === 'conductance' ? [`${sp.name} ${num(l.G)} S/m²`] : [];
       });
+      const gates = (itf.gates ?? []).map((g) => g.name);
       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('; ')}` : ''}`,
+        `  ${L.name} | ${R.name}: ${law}${align}${laws.length ? `; crossing by a law: ${laws.join(', ')}` : ''}${blocked.length ? `; blocked: ${blocked.join(', ')}` : ''}${rx.length ? `; reactions: ${rx.join('; ')}` : ''}${gates.length ? `; gates (voltage-dependent, see interfaces[f].gates): ${gates.join(', ')}` : ''}`,
       );
     });
   }

package/src/device.js

@@ -348,12 +348,12 @@ export function normalizeDevice(def) {
     need(nodes.length > 0, `ports[${k}]: the window [${port.from}, ${port.to}] m holds no grid node; widen it or refine the grid`);
     port.nodes = Int32Array.from(nodes);
   });
-  // A node's surface belongs to one electrode.
+  // A node's surface belongs to one electrode, and its gates to one membrane.
   const surfaced = new Int32Array(grid.nNodes).fill(-1);
   ports.forEach((port, k) => {
-    if (port.surface.length === 0) return;
+    if (port.surface.length === 0 && port.gates.length === 0) return;
     for (const g of port.nodes) {
-      need(surfaced[g] < 0, `ports[${k}]: its window overlaps ports[${surfaced[g]}]'s, and both have a surface; a spot of metal has one surface`);
+      need(surfaced[g] < 0, `ports[${k}]: its window overlaps ports[${surfaced[g]}]'s, and both have a surface or gates; a spot of metal has one surface, and of a membrane one set of channels`);
       surfaced[g] = k;
     }
   });
@@ -669,7 +669,7 @@ function normalizeGeometry(g) {
 // the window, `area` (m²/m³) of it per volume.
 function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT) {
   need(isObject(pdef), `${path} must be an object`);
-  fields(pdef, path, ['name', 'region', 'from', 'to', 'V', 'I', 'R', 'terminal', 'species', 'reactions', 'area', 'surface', 'capacitance']);
+  fields(pdef, path, ['name', 'region', 'from', 'to', 'V', 'I', 'R', 'terminal', 'species', 'reactions', 'area', 'surface', 'capacitance', 'gates']);
   let r;
   if (Number.isInteger(pdef.region)) r = pdef.region;
   else r = regions.findIndex((reg) => reg.name === pdef.region);
@@ -690,6 +690,9 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
   const reactions = portReactions(pdef, path, mat, terminal, species, speciesIndex, RT, surface);
   surface.forEach((sp, s) => need(reactions.some((rx) => rx.part.some((p) => p.side === 2 && p.s === s)), `${path}.surface.${sp.name}: no reaction of the port makes or uses it`));
   const capacitance = portCapacitance(pdef, path, mat);
+  // Gates (a membrane's channels): they follow the voltage across the port's capacitance.
+  const gates = normalizeGates(pdef.gates, path, mat, mat);
+  need(gates.length === 0 || capacitance !== null, `${path}.gates: a gate follows the voltage across the port's capacitance (a membrane's), so give the port one`);
   need(pdef.species === undefined ? reactions.length > 0 || capacitance !== null : isObject(pdef.species), `${path}.species must map species names to port links`);
   const links = species.map(() => ({ type: 'blocked' }));
   for (const [sname, raw] of Object.entries(pdef.species ?? {})) {
@@ -698,7 +701,7 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
     const i = speciesIndex.get(sname);
     const link = typeof raw === 'string' ? { type: raw } : raw;
     need(isObject(link) && ['blocked', 'equilibrium', 'conductance', 'exchange'].includes(link.type), `${lpath}.type must be one of blocked, equilibrium, conductance, exchange`);
-    fields(link, lpath, LINK_FIELDS[link.type]);
+    fields(link, lpath, link.type === 'conductance' ? [...LINK_FIELDS.conductance, 'gates'] : LINK_FIELDS[link.type]);
     if (link.type === 'blocked') continue;
     need(mat.present[i], `${lpath}: '${sname}' is absent from ${reg.name} (material '${mat.name}')`);
     if (mat.conductor) need(i === mat.conductor.i, `${lpath}: a conductor exchanges only its carrier, ${species[mat.conductor.i].name}`);
@@ -718,6 +721,7 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
     // On a metal, G is a lumped conductance per area (S/m²), spread over its thickness.
     if (link.type === 'conductance') level.G = mat.conductor ? positive(link.G, `${lpath}.G (S/m², for a conductor)`) / reg.length : positive(link.G, `${lpath}.G (S/m³)`);
     if (link.type === 'exchange') level.k = positive(link.k, `${lpath}.k (mol/(m³·s))`);
+    if (link.type === 'conductance') level.gates = gatedBy(link.gates, gates, lpath, path);
     links[i] = { type: link.type, ...level };
   }
   need(links.some((l) => l.type !== 'blocked') || reactions.length > 0 || capacitance !== null, `${path}.species: the port exchanges no species`);
@@ -731,7 +735,7 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
     area = typeof pdef.area === 'number' ? { value: positive(pdef.area, `${path}.area (m²/m³)`) } : profile(pdef.area, `${path}.area`, 'areas per volume (m²/m³)', (a) => a >= 0, 'an area per volume ≥ 0');
   } else need(pdef.area === undefined, `${path}.area: only an electrode (a port with reactions or a capacitance) has an area`);
   need(surface.length === 0 || reactions.length > 0, `${path}.surface: only an electrode (a port with reactions) has a surface`);
-  return { name: pdef.name ?? path, region: r, from, to, span: reg.length, drive, terminal, species: links, passes, reactions, area, surface, capacitance };
+  return { name: pdef.name ?? path, region: r, from, to, span: reg.length, drive, terminal, species: links, passes, reactions, area, surface, capacitance, gates };
 }
 
 // A capacitance spread through the window: a gate along a channel, an electrode's double layer.
@@ -860,7 +864,7 @@ function normalizeInterface(idef, f, regions, materials, species, speciesIndex,
   // macroscopic limit; the alignment then drops out. 'capacitive': a Helmholtz layer,
   // D = C (Δφ − dipole). Between two ε = 0 (strictly neutral) materials the default is neutral.
   if (matL.conductor || matR.conductor) return normalizeConductorInterface(idef, where, matL, matR, species, speciesIndex, RT);
-  fields(idef, where, ['phi', 'dipole', 'step', 'sheetCharge', 'species', 'reactions']);
+  fields(idef, where, ['phi', 'dipole', 'step', 'sheetCharge', 'species', 'reactions', 'gates']);
   const bothNeutral = (matL.epsr === 0 && matR.epsr === 0) || matL.phiFree || matR.phiFree;
   const rawPhi = idef.phi ?? (bothNeutral ? 'neutral' : 'pinned');
   const phi = typeof rawPhi === 'string' ? { type: rawPhi } : { ...rawPhi };
@@ -916,6 +920,7 @@ function normalizeInterface(idef, f, regions, materials, species, speciesIndex,
   // 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);
+  const gates = normalizeGates(idef.gates, where, matL, matR);
   if (idef.species !== undefined) {
     need(isObject(idef.species), `${where}.species must map species names to interface links`);
     for (const [sname, raw] of Object.entries(idef.species)) {
@@ -924,7 +929,7 @@ 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'] : link.type === 'permeability' ? ['type', 'P'] : ['type']);
+      fields(link, lpath, link.type === 'conductance' ? ['type', 'G', 'gates'] : link.type === 'permeability' ? ['type', 'P', 'gates'] : ['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`);
@@ -934,13 +939,52 @@ function normalizeInterface(idef, f, regions, materials, species, speciesIndex,
         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 };
+      // Gated: P (or G) × Π x_q^p over the face's gates (a channel open with probability m³h, say).
+      links[i] = { ...link, gates: gatedBy(link.gates, gates, lpath, where) };
     }
   }
 
   const reactions = normalizeFaceReactions(idef, where, matL, matR, species, speciesIndex, RT);
   checkReactingLinks(reactions, idef, where, matL, matR, species);
-  return { phi, dipole, sheetCharge, links, reactions, conductor: null };
+  return { phi, dipole, sheetCharge, links, reactions, gates, conductor: null };
+}
+
+// A face's gates (Hodgkin–Huxley): each a fraction x in [0, 1] with first-order kinetics in the
+// voltage across the face, V = φ_right − φ_left,
+//   dx/dt = α(V) (1 − x) − β(V) x,
+// α and β each one of NeuroML's three standard forms, with rate in 1/s and midpoint and scale in
+// volts: 'exp', rate·e^((V − midpoint)/scale); 'sigmoid', rate/(1 + e^((midpoint − V)/scale));
+// 'expLinear', rate·y/(1 − e^(−y)) with y = (V − midpoint)/scale. They scale permeabilities
+// (a link's gates), and nothing else: a gate holds no charge and exchanges no free energy.
+const GATE_RATE_TYPES = ['exp', 'sigmoid', 'expLinear'];
+// A link's gates, { m: 3, h: 1 }, as [[gate index, exponent]], against the gates defined at `where`.
+function gatedBy(raw, gates, lpath, where) {
+  if (raw === undefined) return [];
+  need(isObject(raw), `${lpath}.gates must map gate names to exponents, e.g. { m: 3, h: 1 }`);
+  return Object.entries(raw).map(([gname, p]) => {
+    const q = gates.findIndex((gt) => gt.name === gname);
+    need(q >= 0, `${lpath}.gates.${gname}: no such gate${gates.length ? ` (there are ${gates.map((gt) => gt.name).join(', ')})` : ` (define it in ${where}.gates)`}`);
+    need(Number.isInteger(p) && p >= 1 && p <= 8, `${lpath}.gates.${gname}: the exponent must be a whole number from 1 to 8, got ${JSON.stringify(p)}`);
+    return [q, p];
+  });
+}
+function normalizeGates(raw, where, matL, matR) {
+  if (raw === undefined) return [];
+  need(isObject(raw), `${where}.gates must map gate names to { alpha, beta }`);
+  need(!matL.phiFree && !matR.phiFree, `${where}.gates: a gate follows the voltage across the face, which needs φ on both sides`);
+  return Object.entries(raw).map(([name, gdef]) => {
+    const gpath = `${where}.gates.${name}`;
+    need(isObject(gdef), `${gpath} must be { alpha, beta }`);
+    fields(gdef, gpath, ['alpha', 'beta']);
+    const rate = (r, rpath) => {
+      need(isObject(r) && GATE_RATE_TYPES.includes(r.type), `${rpath} must be { type, rate, midpoint, scale } with type one of ${GATE_RATE_TYPES.join(', ')}`);
+      fields(r, rpath, ['type', 'rate', 'midpoint', 'scale']);
+      const scale = finite(r.scale, `${rpath}.scale (V)`);
+      need(scale !== 0, `${rpath}.scale (V) must not be zero`);
+      return { type: r.type, rate: positive(r.rate, `${rpath}.rate (1/s)`), midpoint: finite(r.midpoint, `${rpath}.midpoint (V)`), scale };
+    };
+    return { name, alpha: rate(gdef.alpha, `${gpath}.alpha`), beta: rate(gdef.beta, `${gpath}.beta`) };
+  });
 }
 
 // A conductor (a metal, or a fast ion conductor): only its one mobile carrier, whose single
@@ -1036,7 +1080,7 @@ function normalizeConductorInterface(idef, where, matL, matR, species, speciesIn
   }
   const reactions = normalizeFaceReactions(idef, where, matL, matR, species, speciesIndex, RT);
   checkReactingLinks(reactions, idef, where, matL, matR, species);
-  return { phi, dipole: 0, zeroCharge, sheetCharge: 0, links, reactions, conductor: { side, i: metal.i } };
+  return { phi, dipole: 0, zeroCharge, sheetCharge: 0, links, reactions, gates: [], conductor: { side, i: metal.i } };
 }
 
 function defaultInterfaceLinks(matL, matR, species) {

package/src/kit.js

@@ -10,6 +10,7 @@ export { parseEquation, stoichiometry, half, SHE, level } from './equation.js';
 export { traces, speciesRole, typeset } from './traces.js';
 export { live } from './live.js';
 export { pulse, square, triangle, ramp, injector, recombination, photogeneration } from './sources.js';
+export { hodgkinHuxley, ghkCurrent } from './channels.js';
 export { describe, unitWarnings } from './describe.js';
 export { recorder } from './recorder.js';
 export { henderson, planck } from './junction.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' | 'phi', region?: string | number }[] }} [opts]
+ * @param {{ every?: number, times?: number[], probes?: ({ x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number } | { interface: number, species?: string, gate?: string })[] }} [opts]
  */
 export function recorder(device, opts = {}) {
   const { every, times, probes } = opts;

package/src/solution.js

@@ -118,6 +118,11 @@ export function makeSolution(solver, result = {}) {
       const sets = (side) => ['pinned', 'bulk'].includes(model.contacts[side].phi.type);
       out.sigma = Float64Array.from(port.nodes, (g) => ((g === 0 && sets('left')) || (g === last && sets('right')) ? 0 : Cs * (solver.termV[2 + k] - zeroCharge - phi[g])));
     }
+    if (port.gates.length > 0) {
+      // A membrane's gates at each node, and the voltage they follow, φ − (V − zeroCharge).
+      out.gates = Object.fromEntries(port.gates.map((gate, q) => [gate.name, Float64Array.from(port.nodes, (g) => u[solver.blockOfNode[g] * M + 1 + n + port.surface.length + q])]));
+      out.Vm = Float64Array.from(port.nodes, (g) => solver._portVoltage(k, g));
+    }
     if (port.area !== null) {
       out.x = Float64Array.from(port.nodes, (g) => model.grid.x[g]);
       out.area = Float64Array.from(solver.portArea[k]);
@@ -148,7 +153,13 @@ export function makeSolution(solver, result = {}) {
     const N = {};
     for (let i = 0; i < n; i++) N[species[i].name] = u[b * M + 1 + i];
     const rates = itf.reactions.map((_, k) => u[b * M + 1 + n + k]); // mol/(m²·s), forward
-    return { left: model.regions[f].name, right: model.regions[f + 1].name, dipole: itf.dipole, sheetCharge: itf.sheetCharge, D: u[b * M], N, rates };
+    const out = { left: model.regions[f].name, right: model.regions[f + 1].name, dipole: itf.dipole, sheetCharge: itf.sheetCharge, D: u[b * M], N, rates };
+    if (itf.gates.length > 0) {
+      // Each gate's fraction open, and the voltage across the face that drives them.
+      out.gates = Object.fromEntries(itf.gates.map((gate, q) => [gate.name, u[solver._gateSlot(f, q)]]));
+      out.V = solver._faceVoltage(f);
+    }
+    return out;
   });
 
   // Bulk reactions: each one's forward rate at every node (mol/(m³·s), NaN where it doesn't run),

package/src/solver.js

@@ -261,17 +261,39 @@ export class SolverError extends Error {
   }
 }
 
+// A gate's rate law (see normalizeGates in device.js) at voltage V: [rate, ∂rate/∂V], 1/s and 1/(s·V).
+function gateRate(law, V) {
+  const { rate, midpoint, scale } = law;
+  if (law.type === 'exp') {
+    const v = rate * Math.exp((V - midpoint) / scale);
+    return [v, v / scale];
+  }
+  if (law.type === 'sigmoid') {
+    const e = Math.exp((midpoint - V) / scale), d = 1 + e;
+    return Number.isFinite(e) ? [rate / d, (rate * e) / (scale * d * d)] : [0, 0];
+  }
+  // expLinear: rate·y/(1 − e^−y), smooth through y = 0 (rate there) and → rate·y for large y
+  const y = (V - midpoint) / scale;
+  if (Math.abs(y) < 1e-6) return [rate * (1 + y / 2), rate / (2 * scale)];
+  if (y < -700) return [0, 0];
+  const em = -Math.expm1(-y), ey = Math.exp(-y); // 1 − e^−y, e^−y
+  return [(rate * y) / em, (rate * (em - y * ey)) / (em * em * scale)];
+}
+
 export class Solver {
   constructor(model) {
     this.model = model;
     const { grid, species, materials, regions, contacts } = model;
     const n = species.length;
     // Slots per block: φ̂ (or D, or a conductor's segment flux J), one per species, and at a face
-    // one per face reaction (its rate), as many as the busiest face has.
-    const nRx = model.interfaces.reduce((m, itf) => Math.max(m, itf.reactions.length), 0);
+    // one per face reaction (its rate) and one per gate (its fraction open), as many as the
+    // busiest face has.
+    const nRx = model.interfaces.reduce((m, itf) => Math.max(m, itf.reactions.length + itf.gates.length), 0);
     // (and at an electrode port's nodes, one per surface species: its coverage's η)
     const nSurf = model.ports.reduce((m, port) => Math.max(m, port.surface.length), 0);
-    const M = n + 1 + Math.max(nRx, nSurf);
+    // (and a membrane port's gates, after them: each one's fraction open)
+    const nPortSlots = model.ports.reduce((m, port) => Math.max(m, port.surface.length + port.gates.length), 0);
+    const M = n + 1 + Math.max(nRx, nPortSlots);
     const nNodes = grid.nNodes;
     const nFaces = regions.length - 1;
     const nB = nNodes + nFaces;
@@ -306,6 +328,20 @@ export class Solver {
     // The bare fraction θ₀, directly (1 − Σθ cancels as θ → 1); 1 where there's no surface.
     this.th0 = new Float64Array(nNodes).fill(1);
     this.th0Old = new Float64Array(nNodes).fill(1);
+    // Gates: each one's slot (at a face, after its reaction rates; at a membrane port's nodes, after
+    // the surface's coverages) and value at the step's start. Faces' first, then ports', node by
+    // node through each window.
+    this.gatePort = new Int32Array(nNodes).fill(-1);
+    model.ports.forEach((port, k) => port.gates.length > 0 && port.nodes.forEach((g) => (this.gatePort[g] = k)));
+    this.gateList = [
+      ...model.interfaces.flatMap((itf, f) => itf.gates.map((gate, q) => ({ f, q, gate, o: this.blockOfFace[f] * M + 1 + n + itf.reactions.length + q }))),
+      ...model.ports.flatMap((port, k) => Array.from(port.nodes).flatMap((g) => port.gates.map((gate, q) => ({ port: k, g, q, gate, o: this.blockOfNode[g] * M + 1 + n + port.surface.length + q })))),
+    ];
+    this.gateOld = new Float64Array(this.gateList.length);
+    this.gateIndex = new Int32Array(nFaces); // face f's first gate in gateList
+    let j = 0;
+    for (let f = 0; f < nFaces; j += model.interfaces[f].gates.length, f++) this.gateIndex[f] = j;
+    this.portGateIndex = model.ports.map((port) => ((j += port.nodes.length * port.gates.length), j - port.nodes.length * port.gates.length));
 
     // Per-node material data, flattened [g·n + i].
     this.present = new Uint8Array(nNodes * n);
@@ -574,12 +610,14 @@ export class Solver {
       for (let i = 0; i < n; i++) active[b * M + 1 + i] = this.present[g * n + i];
       const k = this.surfPort[g];
       if (k >= 0) for (let q = 0; q < model.ports[k].surface.length; q++) active[b * M + 1 + n + q] = 1;
+      const kg = this.gatePort[g], pg = model.ports[kg];
+      if (kg >= 0) for (let q = 0; q < pg.gates.length; q++) active[b * M + 1 + n + pg.surface.length + q] = 1;
     }
     model.interfaces.forEach((itf, f) => {
       const bf = this.blockOfFace[f];
       active[bf * M] = itf.phi.type === 'neutral' ? 0 : 1;
       for (let i = 0; i < n; i++) active[bf * M + 1 + i] = itf.links[i].type === 'blocked' ? 0 : 1;
-      for (let k = 0; k < itf.reactions.length; k++) active[bf * M + 1 + n + k] = 1;
+      for (let k = 0; k < itf.reactions.length + itf.gates.length; k++) active[bf * M + 1 + n + k] = 1;
     });
     const sizes = new Int32Array(nB), loc = (this.loc = new Int32Array(nB * M).fill(-1));
     for (let b = 0; b < nB; b++) for (let r = 0; r < M; r++) if (active[b * M + r]) loc[b * M + r] = sizes[b]++;
@@ -1393,6 +1431,11 @@ export class Solver {
       });
       if (w > 0) this.termV[k] = port.capacitance.zeroCharge + sum / w;
     }
+    // Gates start open as far as the starting voltage across their face holds them, α/(α + β).
+    for (const gt of this.gateList) {
+      const { gate, o } = gt, V = this._gateVoltage(gt), a = gateRate(gate.alpha, V)[0], b = gateRate(gate.beta, V)[0];
+      u[o] = a + b > 0 ? a / (a + b) : 0;
+    }
     // A floating electrode spread through a port (without a double layer) starts where its
     // reactions pass the current it's set (none, behind a resistance): at its mixed potential in
     // the start's composition, not level with a held terminal, which can be volts away and pass
@@ -1601,6 +1644,7 @@ export class Solver {
     const { grid, materials, regions } = model;
     sys.clear();
     res.fill(0);
+    this.dtNow = dt;
     if (this.lin) this.lin.reset(1 / dt);
     this.computeConcentrations();
 
@@ -1752,7 +1796,7 @@ export class Solver {
   // A start-of-step net charge (round-off in a solved state) isn't carried over: the neutrality
   // row holds the new state neutral.
   _chargeRows(dt) {
-    const { n, M, res, c, cOld, z, sys, loc, present, termB, termC } = this, R = this.rix, F = FARADAY;
+    const { n, M, res, c, cOld, z, sys, loc, present, termB, termC } = this, R = this.rix, F = FARADAY, live = this._liveTerms();
     const { A, B, C, sizes, offA, offB, offC } = sys, vol = this.model.grid.vol, last = this.nB - 1;
     for (const g of this.chargeNodes) {
       const b = this.blockOfNode[g], lb = b * M, m = sizes[b], mp = b > 0 ? sizes[b - 1] : 0, mn = b < last ? sizes[b + 1] : 0;
@@ -1776,7 +1820,7 @@ export class Solver {
         for (let q = 0, o = offB[b] + lk * m, s = offB[b] + li * m; q < m; q++) B[o + q] += w * B[s + q];
         for (let q = 0, o = offC[b] + lk * mn, s = offC[b] + li * mn; q < mn; q++) C[o + q] += w * C[s + q];
         res[rk] += w * res[ri];
-        for (let t = 0; t < termB.length; t++) termB[t][rk] += w * termB[t][ri];
+        for (const t of live) termB[t][rk] += w * termB[t][ri];
         if (this.lin) this.lin.combine(rk, ri, w);
       }
       // Columns: φ̂' = φ̂ with η fixed becomes φ̂ with η_i shifted by z_i, wherever node g's
@@ -1787,7 +1831,7 @@ export class Solver {
         for (let r = 0, o = offB[b]; r < m; r++) B[o + r * m + p] += zi * B[o + r * m + li];
         if (b > 0) for (let r = 0, mr = mp, o = offC[b - 1]; r < mr; r++) C[o + r * m + p] += zi * C[o + r * m + li];
         if (b < last) for (let r = 0, mr = mn, o = offA[b + 1]; r < mr; r++) A[o + r * m + p] += zi * A[o + r * m + li];
-        for (let t = 0; t < termC.length; t++) termC[t][R[lb]] += zi * termC[t][R[lb + 1 + i]];
+        for (const t of live) termC[t][R[lb]] += zi * termC[t][R[lb + 1 + i]];
       }
       // Storage on the other charged balances, and neutrality: no φ̂' terms, exactly.
       const v = vol[g], oB = offB[b];
@@ -2036,14 +2080,21 @@ export class Solver {
         // 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 gl = grid.regionEnd[f], gr = gl + 1, kl = gl * n + i, kr = gr * n + i, zi = z[i], link = itf.links[i];
         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
+        // Gated: P × Π x^p, each x taken in [0, 1] (Newton's iterates can stray past its ends).
+        const gated = link.gates ?? [], gx = (q) => u[this._gateSlot(f, q)];
+        const P = link.P * (gated.length ? this._open(gated, gx) : 1);
         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);
+        for (const [q, p] of gated) {
+          const dO = this._dOpen(gated, q, p, gx);
+          if (dO !== 0) this._j(bf, r, bf, 1 + n + itf.reactions.length + q, link.P * bernoulli(d) * this.c[kl] * E * dO);
+        }
         this._j(bf, r, bL, r, -gBc);
         this._j(bf, r, bR, r, gBc * (E + 1));
         if (zi !== 0) {
@@ -2051,12 +2102,18 @@ export class Solver {
           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);
+        // conductance: J = G (V_L − V_R), V = V_T η / z  ⇒  N = G V_T (η_L − η_R) / (z² F); gated,
+        // G times Π x^p
+        const gated = itf.links[i].gates ?? [], gx = (q) => u[this._gateSlot(f, q)];
+        const gG0 = (itf.links[i].G * VT) / (z[i] * z[i] * F), gG = gG0 * (gated.length ? this._open(gated, gx) : 1);
         res[R[o]] = u[o] - gG * deta;
         this._j(bf, r, bf, r, 1);
         this._j(bf, r, bL, r, -gG);
         this._j(bf, r, bR, r, gG);
+        for (const [q, p] of gated) {
+          const dO = this._dOpen(gated, q, p, gx);
+          if (dO !== 0) this._j(bf, r, bf, 1 + n + itf.reactions.length + q, -gG0 * deta * dO);
+        }
       }
       res[R[bL * M + r]] += Af * u[o];
       this._j(bL, r, bf, r, Af);
@@ -2064,6 +2121,46 @@ export class Solver {
       this._j(bR, r, bf, r, -Af);
     }
     itf.reactions.forEach((rx, k) => this._faceReaction(rx, k, f, bf, bL, bR, Af));
+    if (itf.gates.length > 0) this._faceGates(f, bf, bL, bR);
+  }
+
+  // Full index of face f's gate q (its fraction open).
+  _gateSlot(f, q) {
+    return this.blockOfFace[f] * this.M + 1 + this.n + this.model.interfaces[f].reactions.length + q;
+  }
+
+  // The voltage a gate follows: across its face, or across its port's capacitance at its node.
+  _gateVoltage(gt) {
+    return gt.port === undefined ? this._faceVoltage(gt.f) : this._portVoltage(gt.port, gt.g);
+  }
+
+  // The voltage across port k's capacitance at node g, φ − (V − zeroCharge) (V): a membrane's,
+  // inside (the region) minus outside.
+  _portVoltage(k, g) {
+    const { M, u, uLo, VT } = this, b = this.blockOfNode[g], port = this.model.ports[k];
+    return VT * (u[b * M] + uLo[b * M]) - (this.termV[2 + k] - port.capacitance.zeroCharge);
+  }
+
+  // The voltage across face f, φ_right − φ_left (V).
+  _faceVoltage(f) {
+    const { M, u, uLo, VT } = this, bf = this.blockOfFace[f], bL = bf - 1, bR = bf + 1;
+    return VT * (u[bR * M] - u[bL * M] + (uLo[bR * M] - uLo[bL * M]));
+  }
+
+  // Face f's gates, each a row (x − x_old)/dt = α(1 − x) − βx in the voltage across the face.
+  _faceGates(f, bf, bL, bR) {
+    const { res, VT } = this, R = this.rix, itf = this.model.interfaces[f], dt = this.dtNow;
+    const V = this._faceVoltage(f), k0 = 1 + this.n + itf.reactions.length;
+    itf.gates.forEach((gate, q) => {
+      const o = this._gateSlot(f, q), x = this.u[o];
+      const [a, da] = gateRate(gate.alpha, V), [b, db] = gateRate(gate.beta, V);
+      const store = Number.isFinite(dt) ? 1 / dt : 0, j = this.gateIndex[f] + q;
+      res[R[o]] = store * (x - this.gateOld[j]) - (a * (1 - x) - b * x);
+      this._j(bf, k0 + q, bf, k0 + q, store + a + b);
+      const dV = -(da * (1 - x) - db * x) * VT; // per unit φ̂_R, and minus that per unit φ̂_L
+      this._j(bf, k0 + q, bR, 0, dV);
+      this._j(bf, k0 + q, bL, 0, -dV);
+    });
   }
 
   // Scharfetter–Gummel with non-ideal statistics. The excess ex = ζ − ln(c/c_ref) acts as an
@@ -2345,16 +2442,26 @@ export class Solver {
     }
   }
 
+  // The terminals whose ∂res/∂V (termB) and ∂I/∂x (termC) are kept, exactly: the floating ones,
+  // which the Newton solve borders on, or all of them (allTerminals: for the impedance, which reads
+  // its terminal's). A held terminal's are otherwise left as they fall (written but not kept
+  // consistent), which spares a device with dozens of ports (an axon's nodes of Ranvier) the cost
+  // of carrying each one's two dense vectors through every assembly.
+  _liveTerms() {
+    if (this.allTerminals) return this._allTerms ?? (this._allTerms = this.terms.map((_, k) => k));
+    return this.floating;
+  }
+
   // Every terminal's terms: its voltage held or floating, how the residual depends on it
   // (termB), its current into the device (termI) and how that depends on the state (termC).
   _terminals(dt) {
     this._refreshSources();
-    for (let k = 0; k < this.terms.length; k++) {
+    for (const k of this._liveTerms()) {
       this.termB[k].fill(0);
       this.termC[k].fill(0);
-      this.termDI[k] = 0;
-      this.termI[k] = 0;
     }
+    this.termDI.fill(0);
+    this.termI.fill(0);
     this.qg.fill(0);
     this.qgSlope.fill(0);
     this.model.ports.forEach((port, k) => this._port(port, this.portFlux[k], 2 + k, dt, false));
@@ -2417,8 +2524,11 @@ export class Solver {
           B[R[o]] += -z[i] / VT;
           continue;
         }
-        // conductance: s = G V_T (η_out − η)/(z² F); exchange: s = k (η_out − η)
-        const kk = link.type === 'conductance' ? (link.G * VT) / (z[i] * z[i] * F) : link.k;
+        // conductance: s = G V_T (η_out − η)/(z² F); exchange: s = k (η_out − η). Gated, G times
+        // Π x^p, the gates at this node (each taken in [0, 1]).
+        const kk0 = link.type === 'conductance' ? (link.G * VT) / (z[i] * z[i] * F) : link.k;
+        const gated = link.gates ?? [], q0 = 1 + n + port.surface.length;
+        const open = gated.length ? this._open(gated, (q) => u[b * M + q0 + q]) : 1, kk = kk0 * open;
         res[R[o]] -= v * kk * deta;
         this._j(b, r, b, r, v * kk);
         flux[i] += v * kk * deta;
@@ -2427,6 +2537,12 @@ export class Solver {
           C[R[o]] += -zF * v * kk;
           this.termDI[k] += (zF * v * kk * z[i]) / VT;
         }
+        for (const [q, p] of gated) {
+          const d = this._dOpen(gated, q, p, (qq) => u[b * M + q0 + qq]);
+          if (d === 0) continue;
+          this._j(b, r, b, q0 + q, -v * kk0 * deta * d);
+          if (z[i] !== 0) C[R[b * M + q0 + q]] += zF * v * kk0 * deta * d;
+        }
       }
     }
     if (holds) {
@@ -2435,6 +2551,7 @@ export class Solver {
     }
     port.reactions.forEach((rx, x) => this._portReaction(port, rx, this.portArea[k - 2], this.portRates[k - 2][x], flux, k));
     if (port.capacitance) this._portCapacitance(port, k, dt);
+    if (port.gates.length > 0) this._portGates(port, k, dt);
     if (port.surface.length > 0 && Number.isFinite(dt)) this._surfaceStorage(port, dt);
   }
 
@@ -2503,6 +2620,38 @@ export class Solver {
   // on the port's side, so each node's charge balance (its φ row) gains vol·a·σ, and the port
   // passes the charging current d(Σ vol·a·σ)/dt (none in a steady state). An end node whose φ its
   // contact sets is left to the contact.
+  // A membrane port's gates, at each node of its window: (x − x_old)/dt = α(1 − x) − βx in the
+  // voltage across its capacitance there, φ − (V − zeroCharge).
+  _portGates(port, k, dt) {
+    const { n, res, VT } = this, R = this.rix, B = this.termB[k], store = Number.isFinite(dt) ? 1 / dt : 0, q0 = 1 + n + port.surface.length;
+    port.nodes.forEach((g, w) => {
+      const b = this.blockOfNode[g], V = this._portVoltage(k - 2, g);
+      port.gates.forEach((gate, q) => {
+        const o = b * this.M + q0 + q, x = this.u[o], j = this.portGateIndex[k - 2] + w * port.gates.length + q;
+        const [a, da] = gateRate(gate.alpha, V), [bb, db] = gateRate(gate.beta, V);
+        res[R[o]] = store * (x - this.gateOld[j]) - (a * (1 - x) - bb * x);
+        this._j(b, q0 + q, b, q0 + q, store + a + bb);
+        const s = -(da * (1 - x) - db * x); // ∂/∂V_m, with V_m = V_T φ̂ − V + zeroCharge
+        this._j(b, q0 + q, b, 0, s * VT);
+        B[R[o]] += -s;
+      });
+    });
+  }
+
+  // Π x^p over a link's gates (each x taken in [0, 1]), and its derivative in gate q.
+  _open(gated, x) {
+    let open = 1;
+    for (const [q, p] of gated) open *= powi(Math.min(1, Math.max(0, x(q))), p);
+    return open;
+  }
+  _dOpen(gated, q, p, x) {
+    const xq = x(q);
+    if (!(xq > 0 && xq < 1)) return 0;
+    let others = 1;
+    for (const [q2, p2] of gated) if (q2 !== q) others *= powi(Math.min(1, Math.max(0, x(q2))), p2);
+    return p * powi(xq, p - 1) * others;
+  }
+
   _portCapacitance(port, k, dt) {
     const { M, u, uLo, res, VT } = this, R = this.rix, vol = this.model.grid.vol, area = this.portArea[k - 2];
     const { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k], B = this.termB[k], Ct = this.termC[k];
@@ -2738,7 +2887,7 @@ export class Solver {
 
   // Scale every row by its largest Jacobian entry (in place, residual too).
   _equilibrate() {
-    const { nB, sys, res, termB } = this;
+    const { nB, sys, res, termB } = this, live = this._liveTerms();
     const { A, B, C, sizes, offA, offB, offC, offX } = sys;
     for (let b = 0; b < nB; b++) {
       const m = sizes[b], mp = b > 0 ? sizes[b - 1] : 0, mn = b < nB - 1 ? sizes[b + 1] : 0;
@@ -2758,7 +2907,7 @@ export class Solver {
         for (let k = 0; k < m; k++) B[ob + k] *= s;
         for (let k = 0; k < mn; k++) C[oc + k] *= s;
         res[offX[b] + r] *= s;
-        for (let k = 0; k < termB.length; k++) termB[k][offX[b] + r] *= s; // (each terminal's ∂/∂V)
+        for (const k of live) termB[k][offX[b] + r] *= s; // (each terminal's ∂/∂V)
       }
     }
   }
@@ -2883,6 +3032,7 @@ export class Solver {
       const k = this.surfPort[g]; // an electrode surface's coverages, as η
       if (k >= 0) for (let q = 0; q < this.model.ports[k].surface.length; q++) mx = Math.max(mx, Math.abs(delta[R[b * M + 1 + n + q]]));
     }
+    for (const gt of this.gateList) mx = Math.max(mx, Math.abs(delta[R[gt.o]])); // a gate's fraction open
     return mx;
   }
 
@@ -3104,6 +3254,7 @@ export class Solver {
     this.termVPrev.set(this.termV);
     this.computeConcentrations();
     const cN = Float64Array.from(this.c), thN = Float64Array.from(this.th), th0N = Float64Array.from(this.th0);
+    const gN = Float64Array.from(this.gateList, (gt) => this.u[gt.o] + this.uLo[gt.o]);
     // Contact displacement before the step: as it was at the end of the previous step (under
     // the parameters then), so a gate-voltage change shows up as displacement current.
     if (!this.contactDEnd || !this.portQEnd) {
@@ -3124,6 +3275,7 @@ export class Solver {
       for (let k = 0; k < cOld.length; k++) cOld[k] = b1 * cN[k] - b2 * prev.c[k];
       for (let k = 0; k < thN.length; k++) this.thOld[k] = b1 * thN[k] - b2 * prev.th[k];
       for (let k = 0; k < th0N.length; k++) this.th0Old[k] = b1 * th0N[k] - b2 * prev.th0[k];
+      for (let k = 0; k < gN.length; k++) this.gateOld[k] = b1 * gN[k] - b2 * prev.g[k];
       this.contactDStart = { left: b1 * DN.left - b2 * prev.D.left, right: b1 * DN.right - b2 * prev.D.right };
       this.portQStart = QN.map((q, k) => b1 * q - b2 * prev.Q[k]);
       dtEff = dt / a0;
@@ -3131,6 +3283,7 @@ export class Solver {
       this.cOld.set(cN);
       this.thOld.set(thN);
       this.th0Old.set(th0N);
+      this.gateOld.set(gN);
       this.contactDStart = DN;
       this.portQStart = QN;
     }
@@ -3162,7 +3315,7 @@ export class Solver {
     }
     result.bdf = bdf;
     if (result.converged) {
-      this.history.unshift({ t: this.time, dt, u: Float64Array.from(this.uPrev), c: cN, th: thN, th0: th0N, D: DN, Q: QN });
+      this.history.unshift({ t: this.time, dt, u: Float64Array.from(this.uPrev), c: cN, th: thN, th0: th0N, g: gN, D: DN, Q: QN });
       if (this.history.length > 3) this.history.length = 3;
       this.time = tEnd;
       this.lastDt = dtEff;
@@ -3363,9 +3516,22 @@ export class Solver {
     const fail = (m) => {
       throw new DeviceError(m);
     };
-    if (!Array.isArray(probes)) fail('advance: probes must be an array of { x, species, quantity, region }');
+    if (!Array.isArray(probes)) fail('advance: probes must be an array of { x, species, quantity, region }, or { interface, species } / { interface, gate }');
     const plan = probes.map((p, k) => {
       const path = `advance: probes[${k}]`;
+      if (p?.interface !== undefined) {
+        // At a face: a species' flux through it (mol/(m²·s), toward +x), or a gate's fraction open.
+        const f = p.interface, itf = this.model.interfaces[f];
+        if (!(Number.isInteger(f) && itf)) fail(`${path}.interface: no interface ${JSON.stringify(f)} (they're numbered from 0, left to right)`);
+        if (p.gate !== undefined) {
+          const q = itf.gates.findIndex((gt) => gt.name === p.gate);
+          if (q < 0) fail(`${path}.gate: interfaces[${f}] has no gate ${JSON.stringify(p.gate)}${itf.gates.length ? ` (it has ${itf.gates.map((gt) => gt.name).join(', ')})` : ''}`);
+          return { o: this._gateSlot(f, q) };
+        }
+        const i = species.findIndex((sp) => sp.name === p.species);
+        if (i < 0) fail(`${path}.species: no species ${JSON.stringify(p.species)}`);
+        return { o: this.blockOfFace[f] * this.M + 1 + i };
+      }
       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);
@@ -3397,7 +3563,7 @@ export class Solver {
     };
     return {
       out,
-      read: () => plan.map((q) => (1 - q.w) * at(q, q.g) + q.w * at(q, q.g + 1)),
+      read: () => plan.map((q) => (q.o !== undefined ? (this.loc[q.o] < 0 ? 0 : this.u[q.o]) : (1 - q.w) * at(q, q.g) + q.w * at(q, q.g + 1))),
       push: (values) => values.forEach((v, k) => out[k].push(v)),
     };
   }
@@ -3415,6 +3581,7 @@ export class Solver {
       const k = this.surfPort[g]; // an electrode surface's coverages, as η
       if (k >= 0) for (let q = 0; q < this.model.ports[k].surface.length; q++) mx = Math.max(mx, Math.abs(u[b * M + 1 + n + q] - ref[b * M + 1 + n + q]));
     }
+    for (const { o } of this.gateList) mx = Math.max(mx, Math.abs(u[o] - ref[o])); // (a fraction: 1e-3 of m³ is 0.3% of P)
     return mx;
   }
 
@@ -3458,6 +3625,7 @@ export class Solver {
       cOld: Float64Array.from(this.cOld),
       thOld: Float64Array.from(this.thOld),
       th0Old: Float64Array.from(this.th0Old),
+      gateOld: Float64Array.from(this.gateOld),
       time: this.time,
       lastDt: this.lastDt,
       atSteady: this.atSteady,
@@ -3480,6 +3648,7 @@ export class Solver {
     this.cOld.set(s.cOld);
     this.thOld.set(s.thOld);
     this.th0Old.set(s.th0Old);
+    this.gateOld.set(s.gateOld);
     this.time = s.time;
     this.lastDt = s.lastDt;
     this.atSteady = s.atSteady;
@@ -3515,7 +3684,17 @@ export class Solver {
    * Z = δV/δI with I into the device (positive real part for a passive device).
    * @param {ArrayLike<number>} frequencies Hz
    */
-  impedance(frequencies, { profiles = false, terminal = 'right' } = {}) {
+  impedance(frequencies, opts) {
+    const was = this.allTerminals;
+    this.allTerminals = true; // (it reads its terminal's ∂res/∂V and ∂I/∂x)
+    try {
+      return this._impedance(frequencies, opts);
+    } finally {
+      this.allTerminals = was;
+    }
+  }
+
+  _impedance(frequencies, { profiles = false, terminal = 'right' } = {}) {
     const { M, nB, sys, VT } = this;
     const kT = this.terms.findIndex((t) => t.name === terminal);
     if (kT < 0) throw new SolverError(`impedance: no terminal named '${terminal}' (${this.terms.map((t) => t.name).join(', ')})`);
@@ -3527,6 +3706,7 @@ export class Solver {
     this.cOld.set(this.c);
     this.thOld.set(this.th);
     this.th0Old.set(this.th0);
+    this.gateList.forEach((gt, j) => (this.gateOld[j] = this.u[gt.o]));
     this.assemble(Infinity);
     this.contactDStart = { ...this.contactD };
     this.portQStart = Float64Array.from(this.portQ);
@@ -3955,6 +4135,7 @@ export class Solver {
   // Jacobian are left partial (the next assemble() starts afresh). Concentrations must be current.
   _assembleBookkeeping(dt) {
     const { model } = this;
+    this.dtNow = dt;
     const { grid, materials, regions } = model;
     this.res.fill(0);
     for (let r = 0; r < regions.length; r++) {

package/types/channels.d.ts

@@ -0,0 +1,39 @@
+export function ghkCurrent(z: any, inside: any, outside: any, V: any, T: any): number;
+/**
+ * Hodgkin and Huxley's squid-axon channels, for a membrane face with the outside on its left
+ * (so the gates' voltage, φ_right − φ_left, is the membrane potential): the face's `gates`, and
+ * `species` links for Na⁺ (P·m³h), K⁺ (P·n⁴) and the leak (ungated), to spread into the face
+ * beside its φ law, `{ phi: { type: 'capacitive', C: 0.01 }, ...hh }`, adding links (or blocks)
+ * for any other species.
+ *
+ * The currents are GHK's, which rectify, so a permeability matches a conductance at one voltage
+ * only: each is the one whose chord conductance at `at` (rest, −65 mV) is Hodgkin and Huxley's
+ * (`g`: 120, 36 and 0.3 mS/cm²), at the concentrations given. The leak is carried by one ion
+ * (`leak`, of charge `leakZ`: Cl⁻ by default, whose Nernst level in squid is near their leak
+ * reversal, −54 mV). The
+ * rates are theirs at 6.3 °C, scaled to `T` by Q₁₀ = 3.
+ * @param {{ inside: object, outside: object, T?: number, g?: { Na?: number, K?: number, leak?: number },
+ *   leak?: string, leakZ?: number, at?: number, names?: { Na?: string, K?: string } }} opts concentrations in
+ *   mol/m³ by species name, K, S/m², V
+ * @returns {{ gates: object, species: object }}
+ */
+export function hodgkinHuxley({ inside, outside, T, g, leak, leakZ, at, names }?: {
+    inside: object;
+    outside: object;
+    T?: number;
+    g?: {
+        Na?: number;
+        K?: number;
+        leak?: number;
+    };
+    leak?: string;
+    leakZ?: number;
+    at?: number;
+    names?: {
+        Na?: string;
+        K?: string;
+    };
+}): {
+    gates: object;
+    species: object;
+};

package/types/kit.d.ts

@@ -61,6 +61,7 @@ export { build, combine, layer, ohmic, bath } from "./stack.js";
 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 { hodgkinHuxley, ghkCurrent } from "./channels.js";
 export { describe, unitWarnings } from "./describe.js";
 export { henderson, planck } from "./junction.js";
 export { perovskiteCell, PEROVSKITE_SCANS, hysteresis } from "./devices.js";

package/types/recorder.d.ts

@@ -4,17 +4,21 @@
  * 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' | 'phi', region?: string | number }[] }} [opts]
+ * @param {{ every?: number, times?: number[], probes?: ({ x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number } | { interface: number, species?: string, gate?: string })[] }} [opts]
  */
 export function recorder(device: import("./index.js").Device, opts?: {
     every?: number;
     times?: number[];
-    probes?: {
+    probes?: ({
         x: number;
         species?: string;
         quantity?: "c" | "V" | "phi";
         region?: string | number;
-    }[];
+    } | {
+        interface: number;
+        species?: string;
+        gate?: string;
+    })[];
 }): {
     advance: (tEnd: number, aopts?: object) => import("./types.js").Solution;
     frame: (t: number) => import("./types.js").Solution;

package/types/solver.d.ts

@@ -23,6 +23,11 @@ export class Solver {
     thOld: Float64Array<ArrayBuffer>;
     th0: Float64Array<any>;
     th0Old: Float64Array<any>;
+    gatePort: Int32Array<any>;
+    gateList: any[];
+    gateOld: Float64Array<ArrayBuffer>;
+    gateIndex: Int32Array<ArrayBuffer>;
+    portGateIndex: any;
     present: Uint8Array<ArrayBuffer>;
     cRef: Float64Array<ArrayBuffer>;
     mu0hat: Float64Array<ArrayBuffer>;
@@ -181,6 +186,7 @@ export class Solver {
     _j(rb: any, rs: any, cb: any, cs: any, v: any): void;
     /** Assemble residual and Jacobian for a backward-Euler step of size dt. */
     assemble(dt: any): void;
+    dtNow: any;
     transformed: any;
     _nodeConductor(g: any, dt: any): void;
     _nodesDilute(g0: any, g1: any, dt: any): void;
@@ -192,6 +198,11 @@ export class Solver {
     _segmentDisplacement(s: any, bL: any, bR: any, mat: any, h: any): void;
     _segmentsDilute(g0: any, g1: any, region: any, mat: any, vel: any): void;
     _face(f: any): void;
+    _gateSlot(f: any, q: any): any;
+    _gateVoltage(gt: any): number;
+    _portVoltage(k: any, g: any): number;
+    _faceVoltage(f: any): number;
+    _faceGates(f: any, bf: any, bL: any, bR: any): void;
     _segmentConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any): void;
     _segmentConductor(s: any, bL: any, bR: any, mat: any, h: any): void;
     _segmentMixing(s: any, bL: any, bR: any, Dm: any, h: any, mat: any): void;
@@ -207,11 +218,16 @@ export class Solver {
         Ca: number;
     };
     _faceReaction(rx: any, k: any, f: any, bf: any, bL: any, bR: any, Af: any): void;
+    _liveTerms(): any;
+    _allTerms: any;
     _terminals(dt: any): void;
     _circuit(k: any): void;
     _captureRow(b: any, s: any, w: any, into: any): any;
     _port(port: any, flux: any, k: any, dt: any, holds: any): void;
     _portReaction(port: any, rx: any, area: any, rates: any, flux: any, k: any): void;
+    _portGates(port: any, k: any, dt: any): void;
+    _open(gated: any, x: any): number;
+    _dOpen(gated: any, q: any, p: any, x: any): number;
     _portCapacitance(port: any, k: any, dt: any): void;
     _surfaceStorage(port: any, dt: any): void;
     _contact(side: any, dt: any): void;
@@ -310,6 +326,7 @@ export class Solver {
         cOld: Float64Array<ArrayBuffer>;
         thOld: Float64Array<ArrayBuffer>;
         th0Old: Float64Array<ArrayBuffer>;
+        gateOld: Float64Array<ArrayBuffer>;
         time: number;
         lastDt: number;
         atSteady: boolean;
@@ -343,14 +360,22 @@ export class Solver {
      * Z = δV/δI with I into the device (positive real part for a passive device).
      * @param {ArrayLike<number>} frequencies Hz
      */
-    impedance(frequencies: ArrayLike<number>, { profiles, terminal }?: {
+    impedance(frequencies: ArrayLike<number>, opts: any): {
+        f: Float64Array<ArrayBuffer>;
+        Z: {
+            re: Float64Array<any>;
+            im: Float64Array<any>;
+        };
+    };
+    allTerminals: any;
+    _impedance(frequencies: any, { profiles, terminal }?: {
         profiles?: boolean;
         terminal?: string;
     }): {
         f: Float64Array<ArrayBuffer>;
         Z: {
-            re: Float64Array<ArrayBuffer>;
-            im: Float64Array<ArrayBuffer>;
+            re: Float64Array<any>;
+            im: Float64Array<any>;
         };
     };
     _regionShift(yr: any, yi: any): Float64Array<any>[];