driftlet 1.3.0 → 1.3.3

package/README.md

@@ -56,7 +56,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@1.3.0/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@1.3.3/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).
 

package/docs/device.md

@@ -112,9 +112,11 @@ regions: [
   material. In a strictly neutral region, $`\sum z \cdot c_0`$ must be zero.
   Where two strictly neutral regions meet at a face that holds ions in equilibrium and their
   `c0` leaves it out of equilibrium (a different fixed charge or immobile ion on each side), the
-  two nodes at the face start in it, as the face reaches it at $`t = 0^+`$: the ions it passes
-  shared between them so their $`\bar\mu`$ is equal across it and each side neutral, each
-  one's amount over the two nodes kept, everything else as `c0` has it.
+  two nodes at the face start a transient in it, as the face reaches it at $`t = 0^+`$: the ions
+  it passes shared between them so their $`\bar\mu`$ is equal across it and each side neutral,
+  each one's amount over the two nodes kept, everything else as `c0` has it. (The first time
+  step from a cold start does this; a steady solve starts from `c0` as given, which it reaches
+  better from.)
   An entry can instead be a profile, `{ x: [...], values: [...] }`, against the device's x (m, not
   the region's own), piecewise linear between its points and constant beyond its ends, so a
   transient can start from a state it didn't simulate reaching: a packet already injected, a
@@ -539,7 +541,18 @@ levels are that material's, and the end node takes them through a Donnan step.
 - `'pinned'` with `zeroCharge`: the $`C \to \infty`$ limit,
   $`\phi_{\mathrm{edge}} = V - \mathtt{zeroCharge}`$. This is what a "fixed $`\phi`$" boundary honestly
   means. For example, a Schottky barrier $`\phi_B`$ on n-type material with
-  $`\mu^\circ_{\mathrm{e}^-} = 0`$ is `zeroCharge: φ_B`.
+  $`\mu^\circ_{\mathrm{e}^-} = 0`$ is `zeroCharge: φ_B`. With a carrier linked in equilibrium, a
+  pinned contact sets that carrier's density at the edge,
+  $`c_{\mathrm{edge}} = c_{\mathrm{ref}} \exp\big((z F\,\mathtt{zeroCharge} - \mu^\circ)/RT\big)`$, so a contact that injects holes at
+  $`N_v`$ (their `cRef`, $`\mu^\circ = 0`$) is `zeroCharge: 0`, and a 0.5 eV barrier for them is
+  `zeroCharge: -0.5`. This is the contact for a layer of one carrier with nothing to neutralise it
+  (a hole-only organic diode): `ohmic()`'s `'bulk'` law, local neutrality, can't hold there.
+
+An ideally blocking electrode (inert: no reactions, nothing crossing) is a contact with no
+terminal species and no links, `{ V, phi: 'pinned', zeroCharge }`: the solution's diffuse layer
+is its whole double layer (the validation suite's Macdonald impedance is this cell), and a Stern layer in
+series is `phi: { type: 'capacitive', C }` in place of `'pinned'`. (A metal layer behind a
+capacitive face of large C does the same at more cost, and its C is warned of as a unit slip.)
 
 A Schottky contact is that pinned barrier with its carriers passing at their emission velocities:
 `{ V, terminal: 'e-', species: { 'e-': { type: 'velocity', v }, 'h+': { type: 'velocity', v: vp, offset: 0 } }, phi: 'pinned', zeroCharge: φ_B }`,
@@ -753,8 +766,12 @@ as for reactions, and the window holds the opposite. Each node's charge balance
 Gauss's law averaged across the section, $`-\partial_x(\varepsilon\,\partial_x\phi) = \rho + a\sigma`$,
 and at $`\varepsilon = 0`$ neutrality $`\rho + a\sigma = 0`$, the mobile species rearranging to supply
 it (counter-ions in, co-ions out). The port passes the charging current, $`d(\int a\sigma\,dV)/dt`$,
-none in a steady state. Capacitances on overlapping windows add (a channel's top and bottom
-gates). A capacitance alone, driven by a current, only charges: it starts uncharged, `advance()`
+none in a steady state. `zeroCharge` is in the frame a contact's is (see the capacitive contact
+above): $`V - \phi`$ at zero charge, with $`\phi`$ the device's own, which a bath or contact sets
+(beside a bath referenced to Cl⁻, with the library's μ°, it sits near −1.4 V). Omitted, it's 0, so
+a port held at V = 0 there starts charged by 1.4 V; to start it uncharged, give `zeroCharge` = V −
+φ at its window (`sol.phi` after a solve). Capacitances on overlapping windows add (a channel's
+top and bottom gates). A capacitance alone, driven by a current, only charges: it starts uncharged, `advance()`
 follows it, and `solve()` refuses (there's no steady state, as for a gate contact driven by one).
 
 ```js nocheck
@@ -1004,14 +1021,19 @@ const now = dev.solution();                   // snapshot of the current state
   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
-  device. A held terminal's voltage is perturbed, or a driven one's current; the other terminals
+  device, its input impedance whether it's held or driven by a current (for a driven one, about
+  the state its drive holds: solve() it held, then set its I, solve(), then impedance()); the other terminals
   keep their drives (held ones at AC ground, driven ones open), so at least one other must be held
   for the current to return (with every other one driven, the impedance is infinite, and an error
   says to measure at a driven one). A terminal behind a resistance can't be the one measured: the
   resistance belongs to the external circuit. The grid must resolve how far the signal reaches,
   and nothing warns of it: in a porous electrode, $`\sqrt{\kappa/(\omega C a)}`$ (cells of 2 µm
   against a 3.4 µm depth put Z 7% off, falling as the cells do; at an electrode, the diffusion
-  length $`\sqrt{2D/\omega}`$ at the highest frequency). The result is `{ f, Z: { re, im },
+  length $`\sqrt{2D/\omega}`$ at the highest frequency, and coarser than that, a port's window
+  edges falling mid-cell moved a faradaic C 17%); and a double layer's capacitance wants cells
+  well inside its Debye length (0.1 M NaCl: hmin λ_D/2.4 read C_dl 2.1% low, 0.1 nm 0.5%, 0.05 nm
+  to 5e-4; the warning about unresolved double layers starts only at λ_D). `relError` is the
+  round-off's, not the grid's. The result is `{ f, Z: { re, im },
   relError, warnings }`: `relError[k]`, each Z's estimated error relative to $`|Z|`$ (from
   round-off in the current and the solves' residuals, and cautious: it can exceed the true error
   many times), and the warnings, the steady state's and one where a Z isn't resolved (an error
@@ -1022,7 +1044,10 @@ const now = dev.solution();                   // snapshot of the current state
   terminal is driven by a current.
 - `set(patch)` merges plain objects deeply (arrays are replaced), except that a contact given `V`
   or `I` drops the other (and given `I`, any series `R`): `{ contacts: { right: { I: 0 } } }`
-  switches it to open circuit, whether it was held or behind a resistance. A patch that changes only the
+  switches it to open circuit, whether it was held or behind a resistance. Given `V` alone, a terminal
+  behind a resistance stays behind it: `{ V, R: undefined }` takes the resistance off (`R: 0` and
+  `null` are refused, and `undefined` doesn't survive JSON, so a worker's patch says it this way in
+  JavaScript). A patch that changes only the
   terminals' drives (`V`, `I`, `R`) updates them in place, cheaply, keeping everything else.
   Otherwise the device is rebuilt: the current state carries over while the species, regions
   and terminals are unchanged (on a new grid, interpolated onto its nodes, so a floating gate

package/docs/kit.md

@@ -59,8 +59,9 @@ console.log(`I = ${sol.current.toFixed(1)} A/m²`);
   infinite-recombination contact; `['e-']` alone is selective, and is the current collector on
   a metal region). `bath(c, reference, drive, { offset, material })` is a bath whose terminal voltage is
   the level of its `reference` species, as an electrode reversible to it would read (`offset`
-  places that species relative to the terminal voltage, e.g. to read a solution's potentials
-  against SHE). `bath(c, drive)`, without a reference, is a bath whose terminal voltage is its
+  places that species relative to the terminal voltage, its level at V + `offset`, e.g. to read a
+  solution's potentials against SHE). Every species a bath lists is held at its level there, so
+  one absent from the bulk (a product) is given as a trace, not 0. `bath(c, drive)`, without a reference, is a bath whose terminal voltage is its
   φ: an ideal salt bridge, the convention of membrane potentials, so that between two such baths
   V_right − V_left is the φ difference a voltage clamp sets. A drive is a voltage, a waveform, or
   `{ V }`, `{ I }`, `{ V, R }`. A bath against a charged layer (an ion exchanger) gives its own
@@ -448,7 +449,10 @@ page can show that its numbers hold up. Pass the solution `solve()` or `advance(
   term named by its equation; two with the same equation (radiative and SRH recombination, both
   `e- + h+ = 0`) are told apart by their place, `e- + h+ = 0 (bulkReactions[1])`, and
   `sol.bulkReactions[k]` has each one's rates. A species at rest
-  (in equilibrium, flows only of round-off against what it could carry) isn't listed.
+  (in equilibrium, flows only of round-off against what it could carry) isn't listed. Where none
+  is left, it says "equilibrium" only if no flow comes within ε of what it could carry; otherwise
+  it names the largest, which may be round-off or a real flow too small to check this way (a
+  reverse diode's 1 µA/m², 4e-15 of what its holes could carry).
 - **conservation**, in a transient: every closed, unreacting stretch keeps what it held plus
   what came in.
 - **order**, in a steady state (unless `refine: false` or `order: false`): the device solved from

package/docs/numerics.md

@@ -661,10 +661,16 @@ About a steady state, a small sinusoidal excitation at one terminal gives, to fi
   $`v \cdot K`$, displacement), and likewise $`C`$ and $`C'`$ for the terminal currents. The
   time-derivative parts are read off two assemblies, $`J(dt) = J + M/dt`$, with a tiny $`dt`$ so that
   the subtraction loses nothing.
-- **At the measured terminal $`T`$,** a held voltage is perturbed ($`\delta V_T = 1`$, and $`\delta I_T`$
-  read from its $`C`$ row), or a driven current ($`\delta I_T = 1`$, and $`\delta V_T`$ solved for).
-  $`Z = \delta V_T/\delta I_T`$, with $`I`$ into the device. The other terminals keep their drives:
-  held ones at AC ground, driven ones open.
+- **At the measured terminal $`T`$,** its voltage is perturbed ($`\delta V_T = 1`$) and
+  $`\delta I_T`$ read, held or driven by a current alike: $`Z = \delta V_T/\delta I_T`$ is its input
+  impedance either way, with $`I`$ into the device. (Solving a driven one's $`\delta V_T`$ for a unit
+  current instead read its current through its own circuit row, at the contact alone: a reverse
+  diode's 4.3% off $`dV/dI`$.) The other terminals keep their drives: held ones at AC ground,
+  driven ones open. A floating one's circuit row reads its current where that reading's error is
+  least: at its contact, or at any cut between it and a port's window, the same current (through a
+  metal it's the round-off of $`G\,\Delta\eta`$); and where every terminal but $`T`$ floats, the
+  response to $`T`$ with them held (nearly every level shifted alike, its current a difference of
+  large terms) is read through the identity that shifting every terminal alike passes nothing.
 
 Each frequency costs one complex block-Thomas factorisation (rows scaled by their largest
 entry), plus one back-substitution per floating terminal for the bordering. Conserved (blocked)
@@ -945,6 +951,17 @@ A solve that fails falls back stage by stage:
      the floated solve fails, held solves find that voltage instead, by regula falsi within the
      bracket, to 1e-10 of the current. (Not a terminal at no current that keeps an amount or a
      charge: every voltage passes nothing there.)
+   - **A resistance.** A terminal behind a resistance R, its source at $`V_{\mathrm{src}}`$, is
+     found the same way, held at voltages marched from the held terminal's level until the
+     device's current crosses the load line's, $`(V_{\mathrm{src}} - V)/R`$, and floated from
+     beside it. Held at its source instead and the resistance put back, the state would sit
+     $`IR`$ from the answer, and the pseudo-transient relaxes that over $`RC`$ at the pace Newton
+     takes through the swing: a lit Schottky diode passing 0.9 A/m² took 0.05 s behind
+     1 Ω·m² and 105 s behind 10⁵ Ω·m² that way, and takes 33 ms behind any R by the load line
+     (80 fuzzed diodes from 0.01 to 10⁷ Ω·m²: 1835 s → 34 s). That route remains for terminals the load line doesn't
+     fit: several behind resistances, or one beside terminals all driven by currents, where
+     Kirchhoff gives its current and it's held at $`V_{\mathrm{src}} - IR`$ (from there, putting
+     $`R`$ back moves nothing).
    - **The voltages.** The right terminal's voltage ramped to its target: from the contacts'
      voltages at the last converged solve when the state is that solution (the left one first,
      where it moved), and otherwise from level terminals, where a cold start is consistent. (A

package/docs/reliability.md

@@ -97,7 +97,7 @@ recipes.
 
 The validation suite shows driftlet is right where it converges. Whether it converges, on
 devices nobody tuned it for, is what `npm run stress` tests. It builds random but plausible
-devices in five families:
+devices in six families:
 
 | Family | What's drawn |
 |---|---|
@@ -105,6 +105,7 @@ devices in five families:
 | MOS capacitors | Si, Ge or GaAs, doped 1e15–1e18 cm⁻³; oxide 1–20 nm; Au, Al or Pt gate at any flat-band offset; with or without generation |
 | Electrolyte cells | one to three salts from the data library's ions, 0.1 mM–1 M, 1 µm–1 mm; double layers resolved or strictly neutral; bath, reversible or blocking electrodes |
 | Electrodes | Ag, Cu or Zn deposition, or Fe³⁺/Fe²⁺ on platinum, with Butler–Volmer kinetics over four decades of k₀; with or without a supporting salt; against a second electrode or a bath |
+| Reacting solutions | complexations (Na⁺ + A⁻ = NaA, B + A⁻ = BA⁻, …) in 2–3 regions whose faces block some species, so conserved combinations overlap; against a bath, another bath, closed or a K⁺ electrode; sometimes an electrode at no current reducing a closed M⁺ |
 | Liquid junctions | two mixed solutions, 1 µM–1 M, sharp or graded, at open circuit |
 
 Each device goes through what a user would do with it: a cold solve at no bias, and one at a
@@ -114,26 +115,30 @@ after a voltage step; and the impedance about equilibrium, from far below its sl
 to 1 GHz. Every result is judged by `check()`, and by what must hold whatever the device:
 levels flat at equilibrium with no current, warm and cold solves agreeing, the current driven
 being the one passed, the impedance passive (to 1e-3 of |Z|) and, at low frequency, equal to
-the steady dI/dV, a MOS capacitance never above its oxide's, and its gate charge with the back
+the steady dI/dV where it says it's resolved (`relError` under 1%), a MOS capacitance never above its oxide's, and its gate charge with the back
 contact moved what it is with the gate moved the other way. Each case is seeded from its family and index, so
 any failure reruns alone (`npm run stress -- semi 79`).
 
-At 500 devices per family (about three minutes on a desktop), 11,880 of 11,881 scenarios pass:
+At 500 devices per family (about five minutes on a desktop), 16,379 of 16,381 scenarios pass:
 
-| Family | Cold at 0 V | Cold at bias | Warm sweep | Open circuit, current or back contact | Transient | Impedance |
-|---|---|---|---|---|---|---|
-| Semiconductor stacks | 500/500 | 500/500 | 500/500 | 105/105 | 500/500 | 395/395 |
-| MOS capacitors | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
-| Electrolyte cells | 500/500 | 500/500 | 500/500 | | 500/500 | 381/381 |
-| Electrodes | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
-| Liquid junctions | | | | 500/500 | 499/500 | |
+| Family | Cold at 0 V | Cold at bias | Species reversed | Warm sweep | Open circuit, current or back contact | Transient | Impedance |
+|---|---|---|---|---|---|---|---|
+| Semiconductor stacks | 500/500 | 500/500 | 500/500 | 499/500 | 105/105 | 500/500 | 395/395 |
+| MOS capacitors | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
+| Electrolyte cells | 500/500 | 500/500 | 500/500 | 500/500 |  | 500/500 | 381/381 |
+| Electrodes | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 | 500/500 |
+| Reacting solutions | 500/500 | 500/500 | 500/500 | 500/500 |  | 500/500 |  |
+| Liquid junctions |  |  |  |  | 500/500 | 499/500 |  |
 
 (Impedance only where the device has an equilibrium to linearise about; open circuit only for
 lit cells.) The MOS back contact came last: before steady solves held a group of reacting
 carriers flat where it reaches one contact alone, 43 of the 500 failed it, 5 of them silently
-(a gate charge up to 2× off). The one that fails is among the known limits below: a junction on a grid far too
-coarse for its double layers.
-`bench/stress.json` keeps the summary.
+(a gate charge up to 2× off). Of the two that fail, one is among the known limits below, a junction on a grid far too
+coarse for its double layers; the other is a diode whose current, a small difference of large fluxes, a warm sweep
+reaches to 1.8e-6 of what a cold solve does, against the 1e-6 the check asks: Newton's tolerance, not the physics
+(its own current varies 2.8e-6 along the device, its balances converged).
+`bench/stress.json` keeps the summary, and CI runs `npm run stress -- --check` against it: any
+scenario failing that passes there fails the build.
 
 Most of what driftlet's numerics do differently began as a failure here: the impedance's
 current read across the quietest cut of the device rather than at the contact, GMRES judged by

package/docs/statistics.md

@@ -73,6 +73,19 @@ of exponentially. With one species it's Langmuir filling of sites. The dilute re
 $`c_{\mathrm{ref}}`$ is kept. To use the half-filling convention of site models
 ($`e^\zeta = x/(1-x)`$), set `cRef` equal to `cMax`.
 
+`cMax` from an ion's size: a cube of side $`a`$ per site gives $`c_{\mathrm{max}} = 1/(N_A a^3)`$, so
+$`a`$ = 0.66 nm (a hydrated ion, about) is 5.8 M, and 0.5 nm is 13 M. The model counts sites only:
+D falling with concentration, solvent counterflow and ion pairing are left out. On a material from
+`aqueous()`, add it to the material it returns:
+
+```js
+import { AVOGADRO } from 'driftlet';
+import { aqueous } from 'driftlet/kit';
+
+const aq = aqueous(['Cu2+', 'SO42-', 'H+']);
+aq.materials.water.statistics = [{ type: 'lattice', species: ['Cu2+', 'SO42-', 'H+'], cMax: 1 / (AVOGADRO * 0.66e-9 ** 3) }];
+```
+
 ### Redlich–Kister
 
 One species on its own $`c_{\mathrm{max}}`$ sites, with the excess Gibbs energy of mixing per site
@@ -92,7 +105,11 @@ $`\ln\gamma_i = -z_i^2 \ell_B \kappa / (2(1 + \kappa a))`$, with the Bjerrum len
 $`\ell_B = e^2/(4\pi\varepsilon kT)`$ and $`\kappa^2 = F^2 \sum z^2 c / (\varepsilon RT)`$ from the
 solvent permittivity `epsr` (which defaults to the material's, if that's non-zero) and a
 distance of closest approach `a` (default 0, the limiting law). It stops being convex at high
-ionic strength, and the solver then reports a failure.
+ionic strength, and the solver then reports a failure. It goes on a material's `statistics`, as
+any model does; with `aqueous()`, on the piece it returns: `lib.materials.water.statistics =
+[{ type: 'debye-huckel', species: ['H+', 'Cl-'], a: 4.5e-10 }]`. `a` is an ion size (a few
+ångström: tabulated per ion, as Kielland's sizes, or fitted to measured γ±), and it matters:
+in 10 mM HCl, 4.5 Å against the limiting law moves a concentration cell's voltage by 0.6 mV.
 
 Single-ion activity coefficients are a convention: only neutral combinations (the mean
 activity $`\gamma_\pm`$) are measurable. In a strictly neutral ($`\varepsilon = 0`$) material only

package/llms.txt

@@ -30,9 +30,9 @@ materials, insertion hosts), data.md and reliability.md (what's validated, and t
 From a CDN, pin the version you tested against:
 
 ```js nocheck
-import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at the end.
@@ -219,9 +219,9 @@ a CDN needs a long virtual-time budget, 30 s.)
 <span id="readout"></span>
 <div id="figure"></div>
 <script type="module">
-import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.0/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/plot.js';
 
 const def = build({
   T: 300,
@@ -317,6 +317,8 @@ const mos = (Vg, zeroCharge) =>
       layer('Si', units.um(1), { name: 'Si', acceptors: NA }),
       ohmic(0),
     ],
+    // The inversion layer's supply: with it, the low-frequency C–V at every frequency, even
+    // impedance at 1 MHz. Leave it out for the high-frequency curve (see below the code).
     ports: [{ name: 'channel', region: 'Si', from: 0, to: units.nm(1), V: 0, terminal: 'e-', species: { 'e-': 'equilibrium' } }],
     grid: { hmin: units.nm(0.25), hmax: units.nm(50), ratio: 1.15 },
   });
@@ -383,8 +385,9 @@ electrons' V minus φ in the bulk (with the library's μ°), and a Cl⁻ termina
 that, so an electrode held at 0 V beside it is strongly anodic: `describe(def)` says where SHE
 sits, and an offset of that much (`bath(c, 'Cl-', 0, { offset })`) makes the terminal read SHE.
 The working electrode's current is positive when oxidising. The layer's resistance is in series
-(uncompensated IR: keep it thin, or the supporting salt strong); a 100:1 excess of salt still
-leaves the limiting current about 1% off pure diffusion.
+(uncompensated IR: keep it thin, or the supporting salt strong); a 100:1 excess of a 1:1 salt
+still leaves the limiting current about 1% off pure diffusion, and migration counts for more with
+more charge: Cu²⁺ in 1 M H₂SO₄ (20:1) reads 3% above it, with no acid 2×.
 
 ```js
 import { Device, GAS_CONSTANT, FARADAY } from 'driftlet';
@@ -555,7 +558,8 @@ species }` (its flux) or `{ interface: f, gate }`.
   (docs/statistics.md). At no current (`I: 0`), `solve()` keeps the charge it holds: a closed
   battery sits at the OCV of its state of charge, a floating gate keeps its charge.
 - **Other steps.** `dev.step(dt)` is one backward-Euler step, and `dev.impedance(frequencies,
-  { terminal })` the small-signal Z(f) about the steady state, in Ω·m².
+  { terminal })` the small-signal Z(f) about the steady state, in Ω·m²: `{ f, Z: { re, im } }`,
+  each an array over the frequencies (`Z.re[k]`, not `Z[k].re`).
 
 ```js
 import { Device, units, FARADAY } from 'driftlet';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "1.3.0",
+  "version": "1.3.3",
   "description": "Dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for semiconductors, electrochemistry and nerves, fast enough for live web demos",
   "type": "module",
   "exports": {

package/src/checks.js

@@ -181,6 +181,12 @@ function balance(device, sol) {
   // 1e-19 of its scale, to 1e-15), and round-off doesn't. (Above 1e-8 of the scale, any.)
   const balanced = (l) => Math.abs(l.terms.reduce((a, t) => a + t.rate, 0)) <= 1e-9 * size(l);
   const moving = ledgers.filter((l) => size(l) > 1e-8 * scale(l) || (size(l) > 1e-20 * scale(l) && balanced(l)));
+  // What's left unbalanced can be round-off or a small real flow the solve didn't settle (a
+  // reverse diode behind a resistance, 1.3 µA/m² at 4e-15 of its scale, balanced to 8e-5 by a
+  // solve that stalled), and nothing here tells them apart: round-off reaches 8e-12 of the scale
+  // in the stress devices, and one in a thousand of those flows balances to 1%. So above ε of the
+  // scale it isn't called equilibrium: the largest is named, as what balance can't check.
+  const unsure = ledgers.filter((l) => !moving.includes(l) && size(l) > 1e-16 * scale(l)).sort((a, b) => size(b) / scale(b) - size(a) / scale(a))[0];
   let worst = 0;
   const lines = [];
   for (const l of moving) {
@@ -195,7 +201,9 @@ function balance(device, sol) {
   const ok = worst < 1e-6;
   const summary =
     moving.length === 0
-      ? 'nothing flows or reacts (equilibrium)'
+      ? unsure
+        ? `nothing flows that it can tell from round-off: the largest, ${unsure.title} at ${sig(size(unsure))} ${units.rate}${unsure.z !== 0 ? ` (${sig(FARADAY * Math.abs(unsure.z) * size(unsure))} ${units.current})` : ''}, is ${sig(size(unsure) / scale(unsure), 1)} of what it could carry and doesn't balance (to ${sig(Math.abs(unsure.terms.reduce((a, t) => a + t.rate, 0)) / size(unsure), 1)}), so it's round-off, or a flow too small for this check`
+        : 'nothing flows or reacts (equilibrium)'
       : `${moving.length === 1 ? 'one ledger sums' : `${moving.length} ledgers sum`} to zero ${ok ? `(to ${sig(worst, 1)})` : `only to ${sig(worst, 2)}: not a steady state`}: each species' sources and sinks, ${units.rate}, + in or made`;
   // The largest current any charged species carries anywhere: the scale a net current is read against.
   const gross = Math.max(0, ...moving.filter((l) => l.z !== 0).map((l) => FARADAY * Math.abs(l.z) * size(l)));

package/src/describe.js

@@ -114,6 +114,8 @@ export function unitWarnings(def) {
     if (!isObject(p)) return;
     capacitance(`ports[${k}].capacitance.C`, p.capacitance?.C);
     kinetics(`ports[${k}]`, p.reactions);
+    // (an area per volume typed in cm²/cm³ is 100 times too small: a mesh at 10 cm²/cm³ went by)
+    if (typeof p.area === 'number' && p.area > 0 && p.area < 100) warn(`ports[${k}].area`, `${num(p.area)} m²/m³ is under 1 cm² of electrode per cm³; area is m²/m³ (1 cm²/cm³ = 100 m²/m³)`);
   });
   for (const side of ['left', 'right']) {
     const c = def.contacts?.[side];

package/src/device.js

@@ -811,6 +811,7 @@ function normalizePort(pdef, path, regions, materials, species, speciesIndex, RT
       need(speciesIndex.has(sname), `${path}.bath.c.${sname}: unknown species '${sname}'${known(speciesIndex)}`);
       const i = speciesIndex.get(sname);
       need(mat.present[i], `${path}.bath.c.${sname}: '${sname}' is absent from ${reg.name} (material '${mat.name}'), so its level outside means nothing here`);
+      need(v !== 0, `${path}.bath.c.${sname}: a bath holds each species it lists at its level, and at 0 there is none (ln 0); a species absent from the bulk (a product, say) is a trace there, 1e-6 of the rest or so, so that it can leave`);
       cb[i] = positive(v, `${path}.bath.c.${sname}`);
     }
     const zb = bathZeta(mat, cb, reg.background);
@@ -1359,6 +1360,7 @@ function normalizeContact(cdef, side, region, materials, species, speciesIndex,
       need(speciesIndex.has(sname), `${path}.bath.c.${sname}: unknown species '${sname}'${known(speciesIndex)}`);
       const i = speciesIndex.get(sname);
       need(bm.present[i], `${path}.bath.c.${sname}: '${sname}' is absent from ${own ? 'the bath' : 'the end'} material '${bm.name}'`);
+      need(v !== 0, `${path}.bath.c.${sname}: a bath holds each species it lists at its level, and at 0 there is none (ln 0); a species absent from the bulk (a product, say) is a trace there, 1e-6 of the rest or so, so that it can leave`);
       cb[i] = positive(v, `${path}.bath.c.${sname}`);
       charge += species[i].z * cb[i];
       scale += Math.abs(species[i].z) * cb[i];
@@ -1413,6 +1415,20 @@ function normalizeContact(cdef, side, region, materials, species, speciesIndex,
       links.some((l, i) => l.type !== 'blocked' && species[i].z !== 0),
       `${path}.phi: 'bulk' needs at least one connected charged species at this contact`,
     );
+    // Neutral at the contact must be possible: an undoped layer of holes alone never is, and
+    // ohmic(V, ['h+']) on one failed with "nothing specific showed why" (round 16's cold agent).
+    if (!mat.conductor && !mat.phiFree && !mat.models.some((md) => md.type === 'insertion')) {
+      const signs = new Set(species.flatMap((sp, i) => (mat.present[i] && sp.z !== 0 ? [Math.sign(sp.z)] : [])));
+      const fixed = Math.sign(region.fixedCharge ?? 0);
+      if (signs.size === 1 && !(fixed !== 0 && !signs.has(fixed))) {
+        const [only] = signs;
+        throw new DeviceError(
+          `${path}.phi: 'bulk' (what ohmic() and a bath use) holds the contact neutral, but '${region.name ?? region.material}' can't be: ` +
+            `its only charged species are ${only > 0 ? 'positive' : 'negative'} and no fixed charge balances them (an undoped layer of one carrier). ` +
+            "For a contact that sets the carrier's density, pin φ instead: phi: 'pinned' with zeroCharge, the contact's level against the carrier's (see docs/device.md, contacts).",
+        );
+      }
+    }
   }
 
   if (terminal !== null) {