driftlet 1.2.4 → 1.3.2

package/src/timeSteps.js

@@ -21,6 +21,8 @@
 // (ports' charges) }: what BDF2 and the predictor need.
 //
 // step(s, dt, opts) → newton's result (+ bdf)
+//   From a cold start (s.coldStart, outside a steady solve), the faces between strictly neutral
+//   regions first set to their t = 0⁺ equilibrium (equilibrateFaces, src/start.js).
 //   One step from s.time to tEnd = s.time + dt (or s.landing exactly, where it's within 1e-9·dt
 //   of that). Backward Euler; BDF2 when opts.method is 'bdf2', a previous step exists and the
 //   ratio ω = dt/dt_prev ≤ 2: then c* = b1·c_n − b2·c_{n−1} (b1 = (1+ω)/a0, b2 = ω²/((1+ω)a0),
@@ -85,6 +87,7 @@
 
 import { nextBreakpoint } from './device.js';
 import { SolverError } from './solver.js';
+import { equilibrateFaces } from './start.js';
 
 // Lagrange weights at x through the points s0, s1, s2.
 function lagrange3(x, s0, s1, s2) {
@@ -120,6 +123,8 @@ export function advance(s, dt, opts, depth = 0) {
  * the start-of-step values, and dt/a0 replaces dt.
  */
 export function step(s, dt, opts = {}) {
+  // A transient's first step from a cold start begins at its t = 0⁺ (see equilibrateFaces).
+  if (s.coldStart && !s.steady) equilibrateFaces(s);
   // What the step overwrites before Newton runs, for a failed one to put back: the Solution read
   // after it takes its contacts' fluxes against the start-of-step values (a host emptied by its
   // current read its contact's Li⁺ flux 8× off at the same state).
@@ -262,6 +267,7 @@ export function integrate(s, tEnd, opts = {}) {
   const sample = s._probes(opts.probes);
   const trace = { t: [], current: [], voltage: [], ...(sample ? { probes: sample.out } : {}) };
   let steps = 0, rejected = 0, iterations = 0, failed = false;
+  s.modelError = null; // (a statistics model's refusal, for the failure: see newton)
   // Already there (an animation frame with no time to add): nothing to do, and the step size
   // carried to the next call stays as it was. A time already passed, or reached again outside
   // an animation, is most likely advance(dt) read as a duration: say so.
@@ -269,7 +275,7 @@ export function integrate(s, tEnd, opts = {}) {
     const relative = tEnd < s.time || (s.time > 0 && opts.budgetMs === undefined);
     return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace, ...(relative ? { stopped: `advance(${tEnd}) did nothing: ${absolute}. To run for a further dt, advance(sol.time + dt)` } : {}) };
   }
-  const t0 = s.time;
+  const t0 = s.time, fromLayout = s.history.length === 0 && !s.stepped && !s.atSteady; // (c0's layout, not a solution)
   // A cold start whose floating double layers start uncharged far from the equilibrium of an ion
   // link beside them (a capacitive contact or port passing K⁺, its outside level set for the
   // charged steady state): the link closes the gap in the first instant, which can be far below
@@ -390,8 +396,17 @@ export function integrate(s, tEnd, opts = {}) {
   // (What usually does it, most likely first. Round 11's agents read the old list, which led
   // with a drive's jump, as blaming a modest current pulse: a host emptied at its surface, and
   // an electrode at open circuit with no double layer, held only by a slow reaction.)
-  if (failed && violent.length > 0)
+  const unbalanced = s.history.length === 0 && s.time === t0 ? (s.unbalanced ?? []).map((r) => s.model.regions[r].name ?? `regions[${r}]`) : [];
+  if (failed && unbalanced.length > 0 && s.time === t0)
+    stopped = `${at}: the start can't be neutral in ${unbalanced.join(', ')}, strictly neutral (ε = 0): the amounts its c0 gives leave a net charge that no species held at a contact's level can balance, and a step can't move a stored amount at once. Give c0 that balances (with any fixed charge), or leave out of c0 the species a contact feeds, so that they start at its level.`;
+  else if (failed && violent.length > 0)
     stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. The start is violent: ${violent.join('; ')}. A double layer starts uncharged, and what passes beside it closes such a gap in the first instant, faster than any step can follow. For a start in equilibrium, solve() first (the steady state at the starting drives), then change what the experiment changes, then advance(). Where solve() fails from there too, hold that terminal at a voltage, solve(), then let it float (set its I: 0): it keeps the state the held one gave it.`;
+  else if (failed && s.modelError)
+    stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s, the state it reached refused by a statistics model: ${s.modelError}. The model doesn't hold there: a smaller concentration or drive, or a model for it (lattice for crowding).`;
+  else if (failed && fromLayout && steps === 0)
+    // (round 15's fuzzer: the pn template advanced from its c0, a step of 3e-24 s failing, 23 of 62
+    // plain diodes; nothing said to solve first)
+    stopped = `${at}: the first step did not converge even when shortened to ${dt.toExponential(1)} s, from the starting state, which is c0's layout rather than a solution (a junction's depletion not yet formed, say). For a transient from equilibrium, solve() first at the starting drives, then change what the experiment changes, then advance().`;
   else if (failed) stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. Look for: a host or surface driven to its limit (emptied or filled at its surface by a current it can no longer pass); an electrode at open circuit held only by a slow reaction, with no double-layer capacitance to keep its level (give its face one: phi capacitive); a drive's jump too big for one step (ramp it); a driven current the device cannot keep passing (a diode's reverse recovery past its storage time: stop there); or a device the steady solves also find hard.`;
   else if (s.time < tEnd && steps + rejected >= maxSteps) stopped = `${at}: maxSteps (${maxSteps}) used up (${rejected} of them rejected). Call again to go on, or loosen tol.`;
   return { converged: !failed, done: s.time >= tEnd, steps, rejected, iterations, trace, ...(stopped ? { stopped } : {}) };

package/src/types.js

@@ -317,6 +317,9 @@
  * @typedef {object} ImpedanceResult
  * @property {Float64Array} f frequencies, Hz
  * @property {{ re: Float64Array, im: Float64Array }} Z impedance δV/δI at the terminal, I into the device, Ω·m²
+ * @property {Float64Array} relError each Z's estimated error, relative to |Z| (on Re Z and Im Z alike): the current's round-off
+ *   and the solves' residuals; cautious (it can exceed the true error many times). Over 1%, or over 10·|Re Z|/|Z|,
+ *   a warning says so
  * @property {{ phi: ComplexProfile, mu: Record<string, ComplexProfile>, c: Record<string, ComplexProfile> }[]} [profiles]
  *   per frequency, per unit excitation (volt, or A/m² in current mode)
  * @property {string[]} warnings the steady state's warnings, which hold for its impedance too

package/types/assemble.d.ts

@@ -0,0 +1,18 @@
+export class Assembly {
+    _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: boolean;
+    _replaceRow(b: any, rs: any): void;
+    _assembleDifference(dt: any): {
+        rest: any;
+        lin: DifferenceTerms;
+    };
+    sysRest: any;
+    diffTerms: DifferenceTerms;
+    sys: any;
+    lin: DifferenceTerms;
+    _assembleBookkeeping(dt: any): void;
+}
+import { DifferenceTerms } from './difference.js';

package/types/bernoulli.d.ts

@@ -2,3 +2,12 @@
 export function bernoulli(x: any): number;
 /** dB/dx, with B'(0) = −1/2. */
 export function bernoulliDerivative(x: any): number;
+/**
+ * A Scharfetter–Gummel flux N = −g·B(d)·c_L·expm1(Δη) and its derivatives, into `out`: [N, ∂N/∂d,
+ * g·B(d)·c_L (= ∂N/∂η_L), g·B(d)·c_L·e^{Δη} (= −∂N/∂η_R), −g·expm1(Δη)·(B(d) + B′(d)) (the
+ * non-ideal kernel's ∂N/∂ζ_L per unit K_L)]. d is the drift, Δη the difference of levels, so
+ * that c_R = c_L e^{Δη−d}. From d = SG_FAR on, the same flux from the downstream end, N =
+ * g·B(−d)·c_R·expm1(−Δη), whose factors stay finite; ∂N/∂d = N·B′(d)/B(d).
+ */
+export function sgFlux(g: any, d: any, deta: any, cL: any, cR: any, out: any): any;
+export const SG_FAR: 300;

package/types/boundaries.d.ts

@@ -0,0 +1,24 @@
+export function gateRate(law: any, V: any): number[];
+export class BoundaryTerms {
+    _portRate(port: any, rx: any, g: any): number;
+    _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;
+    _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, k?: number): 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;
+}

package/types/impedance.d.ts

@@ -0,0 +1,53 @@
+export class SmallSignal {
+    /**
+     * Small-signal impedance about the current (steady) state, seen at one terminal. Linearising
+     * gives (J + iωM)·δx + Σ B_k δV_k = rhs for the grid's rows, and (C_k + iωC′_k)·δx +
+     * (∂I_k/∂V_k)·δV_k = δI_set,k for each floating terminal's circuit row, with J the steady
+     * Jacobian and M the storage part (from J(dt) = J + M/dt), B_k = ∂res/∂V_k and C_k = ∂I_k/∂x.
+     * At the measured terminal, its voltage is perturbed (rhs = −B δV) and its current read, held
+     * or driven by a current alike (one input impedance; see the contract). The other terminals
+     * keep their drives: held ones at AC ground, driven ones at AC open circuit.
+     * Z = δV/δI with I into the device (positive real part for a passive device).
+     * @param {ArrayLike<number>} frequencies Hz
+     */
+    impedance(frequencies: ArrayLike<number>, opts: any): {
+        f: Float64Array<ArrayBuffer>;
+        Z: {
+            re: Float64Array<any>;
+            im: Float64Array<any>;
+        };
+        relError: Float64Array<any>;
+    };
+    allTerminals: any;
+    _impedance(frequencies: any, { profiles, terminal }?: {
+        profiles?: boolean;
+        terminal?: string;
+    }): {
+        f: Float64Array<ArrayBuffer>;
+        Z: {
+            re: Float64Array<any>;
+            im: Float64Array<any>;
+        };
+        relError: Float64Array<any>;
+    };
+    sourceTime: any;
+    contactDStart: any;
+    portQStart: Float64Array<ArrayBuffer>;
+    lawForm: Map<any, boolean>;
+    _regionShift(yr: any, yi: any): Float64Array<any>[];
+    _regionEdgeRows(): Uint8Array<any>;
+    _currentCuts(): {
+        s: any;
+        idx: any[];
+        g: any[];
+        d: any[];
+    }[];
+    _smallSignalProfiles(xr: any, xi: any): {
+        phi: {
+            re: Float64Array<any>;
+            im: Float64Array<any>;
+        };
+        mu: {};
+        c: {};
+    };
+}

package/types/newton.d.ts

@@ -0,0 +1,7 @@
+export function maxPotentialStep(s: any, delta: any, deltaV?: any): number;
+export function newton(s: any, dt: any, { maxIter, tol, maxStep, islands }?: {
+    maxIter?: number;
+    tol?: number;
+    maxStep?: number;
+    islands?: boolean;
+}): any;

package/types/regions.d.ts

@@ -0,0 +1,61 @@
+export class RegionTerms {
+    _coverages(): void;
+    computeConcentrations(): void;
+    _work(md: any): any;
+    _nodeStatistics(g: any, b: any, phiHat: any): void;
+    _statSlopes(g: any, mat: any): void;
+    _Kz(g: any, i: any): number;
+    /** zᵀKz at node g (per RT): the charge response that sets the screening length. */
+    screening(g: any): number;
+    _dlnc(g: any, i: any, w: any, d: any): void;
+    _nodeConductor(g: any, dt: any): void;
+    _portHeldAt(g: any, i: any): boolean;
+    _nodesDilute(g0: any, g1: any, dt: any): void;
+    _nodeConcentrated(g: any, dt: any): void;
+    _storage(g: any, i: any, dt: any, Kz?: number): void;
+    _chargeRows(dt: any): void;
+    _untransform(delta: any): void;
+    _bulkReactions(g: any, rxs: any): void;
+    _segmentDisplacement(s: any, bL: any, bR: any, mat: any, h: any): any;
+    _segmentsDilute(g0: any, g1: any, region: any, mat: any, vel: any): void;
+    _segmentConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any): void;
+    _fluxConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any, i: any): {
+        N: any;
+        gBcE1: any;
+        dNdd: any;
+        fL: any;
+        cR: any;
+    };
+    _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;
+    mixWork: Float64Array<any>[];
+    _mixCrowded(gL: any, gR: any, bL: any, bR: any, on: any, k0: any): void;
+    _dKslot(g: any, i: any, j: any, t: any): any;
+    _mixBase(gL: any, gR: any, bL: any, bR: any, on: any): {
+        Jl: Float64Array<ArrayBuffer>;
+        Jr: Float64Array<ArrayBuffer>;
+        dcs: Float64Array<ArrayBuffer>;
+    };
+    mixCrowd: {
+        Jl: Float64Array<ArrayBuffer>;
+        Jr: Float64Array<ArrayBuffer>;
+        dcs: Float64Array<ArrayBuffer>;
+    };
+    _Kat(g: any, i: any, j: any): any;
+    _dc(g: any, k: any, d: any): void;
+    bulkRate(rx: any, g: any): number;
+    bulkForward(rx: any, g: any): any;
+    bulkOneWay(rx: any, g: any): number;
+    _srhRate(law: any, cn: any, cp: any, a: any, xn?: number, xp?: number): {
+        rate: number;
+        forward: number;
+        oneWay: number;
+        Cn: number;
+        Cp: number;
+        Ca: number;
+        Cxn: number;
+        Cxp: number;
+    };
+    _srhDegen(gn: any, gq: any, law: any): any[];
+    _srhInto(g: any, i: any, C: any, Cx: any, d: any): void;
+}

package/types/solver.d.ts

@@ -1,3 +1,7 @@
+export function profileAt({ x, values: c }: {
+    x: any;
+    values: any;
+}, at: any): any;
 export class SolverError extends Error {
     constructor(message: any, details: any);
     details: any;
@@ -49,6 +53,8 @@ export class Solver {
     sheetSign: Int8Array<any>;
     conductorLast: Uint8Array<any>;
     K: Float64Array<ArrayBuffer>;
+    nodeDK: Uint8Array<any>;
+    dK: Float64Array<ArrayBuffer>;
     ex: Float64Array<ArrayBuffer>;
     zeta: Float64Array<any>;
     scratch: Map<any, any>;
@@ -56,10 +62,11 @@ export class Solver {
     dB: Float64Array<any>;
     jL: Float64Array<any>;
     jR: Float64Array<any>;
+    sg: Float64Array<ArrayBuffer>;
     time: number;
     lastDt: number;
     atSteady: boolean;
-    lin: DifferenceTerms;
+    lin: any;
     contactFlux: {
         left: Float64Array<any>;
         right: Float64Array<any>;
@@ -126,7 +133,7 @@ export class Solver {
     _activeSlots(): void;
     active: Uint8Array<ArrayBuffer>;
     loc: Int32Array<ArrayBuffer>;
-    sys: any;
+    sys: BlockTridiagonal;
     SINK: number;
     rix: Int32Array<ArrayBuffer>;
     fullOf: Int32Array<ArrayBuffer>;
@@ -224,136 +231,26 @@ export class Solver {
         nodeMaterial: Int32Array<any>;
         phiUndefined: Uint8Array<any>;
     };
-    _directSteady(): boolean;
     _surfaceStart(g: any): void;
     /** Amount (mol per unit area) of surface column j's species, Γ Σ v·a·θ, in the current state. */
     surfaceAmount(j: any): number;
     /** Total amount (mol per unit area) of a stretch's species in the current state. */
     amount(stretch: any): number;
     redrive(): void;
-    deltaV: Float64Array<any>;
-    stuckReactions(): any[];
+    deltaV: any;
     _drivenKey(): any;
     _refreshSources(): void;
     /** η_i (μ̄/RT) of a port's outside level for species i (its electrode's carrier: at V itself). */
     portEta(port: any, i: any): number;
     /** η_i/RT that a fixed contact link imposes (or NaN if the link isn't fixed). */
     contactEta(side: any, i: any): number;
-    /**
-     * Cold start. Each species takes its region's c0 where one is given (for a spectator, it fixes
-     * the conserved amount), else its contact's level. φ in each region is then chosen for local neutrality (node by node where a
-     * profile varies), or continued across the interface dipole if nothing there responds.
-     */
     initFromComposition(): void;
-    _portRate(port: any, rx: any, g: any): number;
-    _materialAt(mat: any, background: any, eta: any, mode: any, cFix: any, ph: any, zeta: any, cc: any): void;
-    _coverages(): void;
-    computeConcentrations(): void;
-    _work(md: any): any;
-    _nodeStatistics(g: any, b: any, phiHat: any): void;
-    _Kz(g: any, i: any): number;
-    /** zᵀKz at node g (per RT): the charge response that sets the screening length. */
-    screening(g: any): number;
-    _dlnc(g: any, i: any, w: any, d: any): void;
-    _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;
-    _portHeldAt(g: any, i: any): boolean;
-    _nodesDilute(g0: any, g1: any, dt: any): void;
-    _nodeConcentrated(g: any, dt: any): void;
-    _storage(g: any, i: any, dt: any, Kz?: number): void;
-    _chargeRows(dt: any): void;
-    _untransform(delta: any): void;
-    _bulkReactions(g: any, rxs: any): void;
-    _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;
-    _fluxConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any, i: any): {
-        N: number;
-        E: number;
-        gBc: number;
-        dNdd: number;
-        fL: number;
-        cR: number;
-    };
-    _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;
-    mixWork: Float64Array<any>[];
-    _dc(g: any, k: any, d: any): void;
-    bulkRate(rx: any, g: any): number;
-    bulkForward(rx: any, g: any): any;
-    bulkOneWay(rx: any, g: any): number;
-    _srhRate(law: any, cn: any, cp: any, a: any, xn?: number, xp?: number, sn?: number, sp?: number): {
-        rate: number;
-        forward: number;
-        oneWay: number;
-        Cn: number;
-        Cp: number;
-        Ca: number;
-    };
-    _srhDegen(gn: any, gq: any, law: any): number[];
-    _degen(g: any, i: any): 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;
-    _replaceRow(b: any, rs: any): void;
-    _equilibrate(): void;
-    _assembleDifference(dt: any): {
-        rest: any;
-        lin: DifferenceTerms;
-    };
-    sysRest: any;
-    diffTerms: DifferenceTerms;
-    _refine(dt: any, delta: any, deltaV: any): boolean;
-    _maxPotentialStep(delta: any, deltaV?: Float64Array<any>): number;
-    /**
-     * Newton iteration for one backward-Euler step from the current cOld.
-     * @returns {{converged: boolean, iterations: number, history: number[]}}
-     */
-    newton(dt: any, { maxIter, tol, maxStep, islands }?: {
-        maxIter?: number;
-        tol?: number;
-        maxStep?: number;
-        islands?: boolean;
-    }): {
-        converged: boolean;
-        iterations: number;
-        history: number[];
-    };
-    _kirchhoff(): number;
-    _noteConditioning(): void;
-    conditioning: {
-        digits: any;
-        x: number;
-        where: string;
-        nodes: any[];
-    };
+    newton(dt: any, opts: any): any;
     /**
      * Advance by dt, splitting the interval into halves (recursively) wherever Newton fails.
      * The end time is always t + dt; the result reports the substeps taken.
      */
     advance(dt: any, opts: any, depth?: number): any;
-    _addToState(d: any, scale: any): void;
     step(dt: any, opts?: {}): any;
     integrate(tEnd: any, opts?: {}): {
         stopped?: string;
@@ -376,6 +273,7 @@ export class Solver {
     };
     _warmFrom(src: any): void;
     solvedV: any;
+    coldStart: any;
     _snapshot(): {
         u: Float64Array<ArrayBuffer>;
         uLo: Float64Array<ArrayBuffer>;
@@ -402,118 +300,14 @@ export class Solver {
         history: any[];
         termV: Float64Array<ArrayBuffer>;
         sourceTime: number;
+        coldStart: any;
     };
     _restore(s: any): void;
     contactDEnd: any;
     passedCurrent(k: any): any;
     _terminalCurrent(): number;
-    /**
-     * Small-signal impedance about the current (steady) state, seen at one terminal. Linearising
-     * gives (J + iωM)·δx + Σ B_k δV_k = rhs for the grid's rows, and (C_k + iωC′_k)·δx +
-     * (∂I_k/∂V_k)·δV_k = δI_set,k for each floating terminal's circuit row, with J the steady
-     * Jacobian and M the storage part (from J(dt) = J + M/dt), B_k = ∂res/∂V_k and C_k = ∂I_k/∂x.
-     * At the measured terminal, a held voltage is perturbed (rhs = −B δV) and its current read
-     * from C, or a driven current is perturbed and its voltage solved for. The other terminals
-     * keep their drives: held ones at AC ground, driven ones at AC open circuit.
-     * Z = δV/δI with I into the device (positive real part for a passive device).
-     * @param {ArrayLike<number>} frequencies Hz
-     */
-    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<any>;
-            im: Float64Array<any>;
-        };
-    };
-    _regionShift(yr: any, yi: any): Float64Array<any>[];
-    _regionEdgeRows(): Uint8Array<any>;
-    _currentCuts(): {
-        s: any;
-        idx: any[];
-        g: any[];
-        d: any[];
-    }[];
     segmentFluxes(): Float64Array<ArrayBuffer>[];
     faceOneWay(f: any): any;
-    _smallSignalProfiles(xr: any, xi: any): {
-        phi: {
-            re: Float64Array<any>;
-            im: Float64Array<any>;
-        };
-        mu: {};
-        c: {};
-    };
-    _assembleBookkeeping(dt: any): void;
     _accumulateBoundaryIntake(dt: any, cN: any): void;
-    slowestTime(): number;
-    fastestTime(): number;
-    /**
-     * Steady state: where a transient from the present state ends, found as the solution of the
-     * steady equations (dt = ∞, no storage term), with no slow modes to wait out, however slow the
-     * physics (e.g. exponentially scarce minority carriers). What the storage term held is held by
-     * the steady system's own rows instead (see src/laws.js): each conserved amount in place of a balance
-     * row that says nothing new, levels that carry nothing held flat, islands' summed balances.
-     * Where Newton from here fails: continuation along the drives, then the pseudo-transient ramp.
-     * The clock is not advanced, and open-system conservation bookkeeping restarts here.
-     */
-    solveSteady(opts?: {}): any;
-    violent: any[];
-    unreached: {
-        terminal: any;
-        target: any;
-        low: any;
-        high: any;
-    };
-    charging: {
-        terminal: any;
-        current: any;
-        what: any[];
-    };
-    steadyAt: number;
-    _solveSteadyAll(opts: any): any;
-    _steadyFromHere(opts: any): any;
-    stepped: boolean;
-    dimmer: boolean;
-    _bound(k: any): boolean;
-    _floatingContinuation(opts: any, r: any): any;
-    _generationContinuation(opts: any, r: any): {
-        converged: boolean;
-        steps: any;
-        iterations: any;
-        history: any;
-    };
-    _continuation(opts: any, k: any, level: any, target: any, r: any, warm: any, hold: any): any;
-    _steadySteps({ maxSteps, tol }?: {
-        maxSteps?: number;
-        tol?: number;
-    }): {
-        converged: boolean;
-        steps: number;
-        iterations: number;
-        history: ({
-            dt: number;
-            converged: any;
-            iterations: any;
-            maxStep?: undefined;
-        } | {
-            dt: number;
-            converged: any;
-            iterations: any;
-            maxStep: number;
-        })[];
-    };
-    _renormalizeSpectators(): void;
-    _diff(): Float64Array<ArrayBuffer>;
 }
-import { DifferenceTerms } from './difference.js';
+import { BlockTridiagonal } from './blockTridiagonal.js';

package/types/start.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cold start. Each species takes its region's c0 where one is given (for a spectator, it fixes
+ * the conserved amount), else its contact's level. φ in each region is then chosen for local neutrality (node by node where a
+ * profile varies), or continued across the interface dipole if nothing there responds.
+ */
+export function initFromComposition(s: any): void;
+/**
+ * The t = 0⁺ state at the faces between strictly neutral regions, taken by the first time step
+ * from a cold start (src/timeSteps.js) and not by a steady solve, which needs no t = 0⁺: there it
+ * was the worse start, its face nodes moved while the rest of a region stayed (a stack whose
+ * middle region started 2.2 V from its neighbour's level failed every steady solve, where the
+ * cold start converged in one).
+ */
+export function equilibrateFaces(s: any): void;

package/types/steady.d.ts

@@ -0,0 +1,81 @@
+export class SteadySolves {
+    slowestTime(): number;
+    _usedMaterials(): any[];
+    fastestTime(): number;
+    /**
+     * Steady state: where a transient from the present state ends, found as the solution of the
+     * steady equations (dt = ∞, no storage term), with no slow transport to wait out (e.g.
+     * exponentially scarce minority carriers); but a slow reaction that alone settles a closed
+     * combination is waited out by time steps, to ~1e12 of the slowest diffusion time (invariant
+     * 5). What the storage term held is held by
+     * the steady system's own rows instead (see src/laws.js): each conserved amount in place of a balance
+     * row that says nothing new, levels that carry nothing held flat, islands' summed balances.
+     * Where Newton from here fails: continuation along the drives, then the pseudo-transient ramp.
+     * The clock is not advanced, and open-system conservation bookkeeping restarts here.
+     */
+    solveSteady(opts?: {}): any;
+    violent: any[];
+    unreached: {
+        terminal: any;
+        target: any;
+        low: any;
+        high: any;
+    };
+    charging: {
+        terminal: any;
+        current: any;
+        what: any;
+    };
+    steady: boolean;
+    steadyAt: any;
+    drifted: any;
+    modelError: any;
+    _solveSteadyAll(opts: any): any;
+    atSteady: any;
+    _steadyFromHere(opts: any): any;
+    conditioning: any;
+    sourceTime: any;
+    solvedV: any[];
+    stepped: boolean;
+    coldStart: boolean;
+    dimmer: boolean;
+    _bound(k: any): any;
+    _floatingContinuation(opts: any, r: any, k?: any, line?: any): any;
+    _resistanceContinuation(opts: any, r: any): any;
+    _generationContinuation(opts: any, r: any): {
+        converged: boolean;
+        steps: any;
+        iterations: any;
+        history: any;
+    };
+    generationScale: number;
+    _continuation(opts: any, k: any, level: any, target: any, r: any, warm: any, hold: any): any;
+    _steadySteps({ maxSteps, tol }?: {
+        maxSteps?: number;
+        tol?: number;
+    }): {
+        converged: boolean;
+        steps: number;
+        iterations: number;
+        history: ({
+            drifted?: boolean;
+            dt: number;
+            converged: any;
+            iterations: any;
+            maxStep?: undefined;
+        } | {
+            dt: number;
+            converged: any;
+            iterations: any;
+            maxStep: number;
+        })[];
+    };
+    time: any;
+    history: any[];
+    dtNext: any;
+    _unkeptAmounts(): any;
+    _renormalizeSpectators(): void;
+    _diff(): any;
+    _directSteady(): any;
+    stuckReactions(): any[];
+}

package/types/types.d.ts

@@ -820,6 +820,12 @@ export type ImpedanceResult = {
         re: Float64Array;
         im: Float64Array;
     };
+    /**
+     * each Z's estimated error, relative to |Z| (on Re Z and Im Z alike): the current's round-off
+     * and the solves' residuals; cautious (it can exceed the true error many times). Over 1%, or over 10·|Re Z|/|Z|,
+     * a warning says so
+     */
+    relError: Float64Array;
     /**
      * per frequency, per unit excitation (volt, or A/m² in current mode)
      */