@driftengine/chemistry 3.61.0

package/dist/reaction/rates.js

@@ -0,0 +1,101 @@
+/**
+ * Reaction rates as tables, because `exp` may not run on a tick.
+ *
+ * **The reasoning is `§7`'s and it is a hard rule rather than a preference.** `AGENTS.md` already
+ * made this call once, for the tyre curve: Pacejka is `sin(atan(…))` and both were banned from the
+ * tick, so the curve became a table and the API came out better than the closed form. The same
+ * applies here with more force. `exp(−Ea/RT)` would be evaluated once per reaction per shell per
+ * parcel per substep — a hundred times the tyre call count — and it varies by twenty orders of
+ * magnitude over the range of interest, which makes it the single easiest place in the engine to
+ * lose determinism to one platform's `exp` differing in the last bit.
+ *
+ * **Knots are uniform in `1/T`, and that is a departure from the design worth recording.** `§7`
+ * says "512 logarithmically-spaced knots, log-`k` stored so the interpolation is in the variable
+ * that is nearly linear" — and `ln k = ln A + n·ln T − Ea/(R·T)` is not nearly linear in `ln T`, it
+ * is *exactly* linear in `1/T` for the `n = 0` form that almost every rate in the library uses. So
+ * the knots are uniform in `1/T`, which puts the interpolation error where the design wanted it.
+ *
+ * **But `k` is stored rather than `ln k`, and that is the other half of the correction.** The
+ * design's own sentence would need an `exp` at every lookup, which is the thing the paragraph above
+ * it forbids — the two halves of `§7` contradict each other, and this is the resolution. Storing
+ * `k` and interpolating linearly costs a real interpolation error, bounded by about `δ²/8` where
+ * `δ` is the change in `ln k` across one knot. At 1,024 knots over 200–3500 K that is under half a
+ * percent for every activation energy in the library, **which is comfortably inside the uncertainty
+ * in the activation energies themselves** — literature values for cellulose pyrolysis differ by
+ * several percent between studies. `rates.test.ts` measures it rather than trusting this paragraph.
+ */
+/** J/(mol·K). */
+export const GAS_CONSTANT = 8.314462618;
+const DEFAULT_MIN = 200;
+const DEFAULT_MAX = 3500;
+const DEFAULT_KNOTS = 1024;
+function tabulate(at, min, max, knots) {
+    if (!(max > min) || !(min > 0)) {
+        throw new Error(`a rate table spans ${min}..${max} K, which is not an ascending positive range`);
+    }
+    const inverseMin = 1 / max;
+    const inverseMax = 1 / min;
+    const rate = new Float64Array(knots);
+    for (let i = 0; i < knots; i++) {
+        const inverse = inverseMin + ((inverseMax - inverseMin) * i) / (knots - 1);
+        rate[i] = at(1 / inverse);
+    }
+    return { minTemperature: min, maxTemperature: max, inverseMin, inverseMax, knots, rate };
+}
+/** `k(T) = A · T^n · exp(−Ea / R·T)`, sampled once so the tick never evaluates it. */
+export function tabulateArrhenius(A, activationEnergy, n = 0, min = DEFAULT_MIN, max = DEFAULT_MAX, knots = DEFAULT_KNOTS) {
+    return tabulate(
+    // determinism: build-time — the Arrhenius table is built once so exp never runs on a tick
+    (t) => A * t ** n * Math.exp(-activationEnergy / (GAS_CONSTANT * t)), min, max, knots);
+}
+/**
+ * The peaked curve an enzyme-catalysed rate actually follows, normalised to one at the optimum.
+ *
+ * Zero at both cardinal ends, one at `optimum`, and **asymmetric in the right direction**: a slow
+ * climb and a sharp fall, because an enzyme denatures far faster than it warms up. Modelling decay
+ * or fermentation with Arrhenius instead gives compost that gets hotter forever, which is the most
+ * common mistake in this area and is refused here structurally rather than by remembering.
+ */
+export function cardinalRate(temperature, min, optimum, max) {
+    if (temperature <= min || temperature >= max)
+        return 0;
+    const above = temperature - min;
+    const numerator = above * above * (temperature - max);
+    const denominator = (optimum - min) *
+        ((optimum - min) * (temperature - optimum) -
+            (optimum - max) * (optimum + min - 2 * temperature));
+    if (denominator === 0)
+        return 0;
+    const value = numerator / denominator;
+    return value > 0 ? value : 0;
+}
+/** A cardinal curve scaled to a peak rate, tabulated the same way an Arrhenius one is. */
+export function tabulateCardinal(peak, min, optimum, max, low = DEFAULT_MIN, high = DEFAULT_MAX, knots = DEFAULT_KNOTS) {
+    if (!(min < optimum)) {
+        throw new Error(`cardinal temperatures are out of order: minimum ${min} is not below optimum ${optimum}`);
+    }
+    if (!(optimum < max)) {
+        throw new Error(`cardinal temperatures are out of order: maximum ${max} is not above optimum ${optimum}`);
+    }
+    return tabulate((t) => peak * cardinalRate(t, min, optimum, max), low, high, knots);
+}
+/**
+ * The rate at a temperature.
+ *
+ * Two multiplications, a floor and a lerp. Clamped at both ends rather than extrapolated: linearly
+ * extrapolating an exponential is how a rate table produces a number with nothing behind it.
+ */
+export function rateAt(table, temperature) {
+    if (temperature <= table.minTemperature)
+        return table.rate[table.knots - 1];
+    if (temperature >= table.maxTemperature)
+        return table.rate[0];
+    const position = ((1 / temperature - table.inverseMin) / (table.inverseMax - table.inverseMin)) *
+        (table.knots - 1);
+    const low = Math.floor(position);
+    const high = low + 1;
+    if (high >= table.knots)
+        return table.rate[table.knots - 1];
+    const at = position - low;
+    return table.rate[low] * (1 - at) + table.rate[high] * at;
+}

package/dist/reaction/reaction.d.ts

@@ -0,0 +1,178 @@
+/**
+ * What a reaction is: stoichiometry, a rate law, and what kind of change it represents.
+ *
+ * **No enthalpy field**, and that is the same decision `SpeciesDefinition` makes about molar mass.
+ * A reaction's `ΔH` is derived from its species' formation enthalpies by Hess's law at
+ * registration, so a number that disagreed with its own species cannot exist. `§5` of the design is
+ * the argument, and CH-0's heating-value test is what makes the underlying numbers trustworthy.
+ *
+ * **No gates yet.** The design's `ReactionGates` — a minimum oxygen fraction, a phase requirement,
+ * a moisture ceiling — are refused in this phase rather than stubbed: an oxygen gate without a gas
+ * field to read is a constant pretending to be physics, and the field is CH-4. The network here
+ * runs on mass action alone.
+ */
+export declare const KIND_DRYING = 0;
+export declare const KIND_PYROLYSIS = 1;
+export declare const KIND_COMBUSTION = 2;
+export declare const KIND_CHAR_OXIDATION = 3;
+export declare const KIND_CALCINATION = 4;
+export declare const KIND_CORROSION = 5;
+export declare const KIND_DISSOLUTION = 6;
+export declare const KIND_DENATURATION = 7;
+export declare const KIND_BROWNING = 8;
+export declare const KIND_BIOLOGICAL = 9;
+export declare const KIND_PHASE_CHANGE = 10;
+export type ReactionKind = typeof KIND_DRYING | typeof KIND_PYROLYSIS | typeof KIND_COMBUSTION | typeof KIND_CHAR_OXIDATION | typeof KIND_CALCINATION | typeof KIND_CORROSION | typeof KIND_DISSOLUTION | typeof KIND_DENATURATION | typeof KIND_BROWNING | typeof KIND_BIOLOGICAL | typeof KIND_PHASE_CHANGE;
+export interface SpeciesAmount {
+    readonly species: string;
+    /** Moles per unit of reaction extent. Fractional is allowed and often necessary. */
+    readonly moles: number;
+}
+/**
+ * `k(T) = A · T^n · exp(−Ea / R·T)`. Monotonic in temperature, which is right for everything a
+ * flame does and wrong for everything an enzyme does.
+ */
+export interface ArrheniusKinetics {
+    readonly type: 'arrhenius';
+    readonly A: number;
+    /** J/mol. */
+    readonly activationEnergy: number;
+    readonly n?: number;
+}
+/**
+ * A peaked curve: zero below `minimum`, one at `optimum`, zero above `maximum`.
+ *
+ * **Enzyme-catalysed rates are not Arrhenius**, and using one gives compost that heats forever.
+ * `§8.6` is the argument; this is where the shape lives.
+ */
+export interface CardinalKinetics {
+    readonly type: 'cardinal';
+    /** The rate at the optimum. */
+    readonly peak: number;
+    readonly minimum: number;
+    readonly optimum: number;
+    readonly maximum: number;
+}
+/**
+ * Arrhenius, capped by how fast the reactant can physically reach the surface.
+ *
+ * **This is what makes char glow for an hour instead of vanishing in seconds, and `§7` says why.**
+ * Above about 800 K the chemistry of carbon oxidation outruns oxygen delivery by an order of
+ * magnitude, so what you are actually watching is transport. The kinetic rate alone gives char that
+ * disappears; the cap gives char that sits there glowing, which is what char does.
+ *
+ * The two combine as a **series resistance** — `1/k = 1/k_kinetic + 1/k_transport` — which is the
+ * same arithmetic a shell boundary uses for the same reason, and it means neither side has to know
+ * about the other. And the transport half rises with the gas moving past, so **blowing on embers
+ * makes them brighter and stops when you stop**.
+ */
+export interface DiffusionKinetics {
+    readonly type: 'diffusion';
+    readonly A: number;
+    /** J/mol. */
+    readonly activationEnergy: number;
+    readonly n?: number;
+    /** The ceiling transport puts on it in still air, per second. */
+    readonly transportLimit: number;
+}
+/** As fast as the reactants allow: the clamp in the solver is the only thing limiting it. */
+export interface InstantKinetics {
+    readonly type: 'instant';
+}
+export type Kinetics = ArrheniusKinetics | CardinalKinetics | DiffusionKinetics | InstantKinetics;
+/**
+ * When a reaction is allowed to run at all.
+ *
+ * Separate from the rate law because it is a different kind of statement: kinetics say how fast,
+ * a gate says whether. Ice does not melt at all below 273.15 K, and expressing that as a very small
+ * Arrhenius rate would be a lie that leaks a trickle of water into every freezer.
+ */
+export interface ReactionGates {
+    /** K. Below this, nothing. */
+    readonly minTemperature?: number;
+    /** K. Above this, nothing. */
+    readonly maxTemperature?: number;
+    /**
+     * K over which a gate opens rather than snapping: upward from `minTemperature`, and downward from
+     * `maxTemperature` where there is one.
+     *
+     * Zero for a pure substance. A few kelvin for a mixture: butter softens over about three, because
+     * it is triglycerides with different melting points, and that band is what makes fat render
+     * slowly instead of switching from solid to liquid.
+     *
+     * **One number for both ends**, because no reaction here wants a sharp ceiling over a soft floor
+     * and a second field would be a knob nobody turns. A reaction with both gates set tapers
+     * symmetrically and is fully open only between them.
+     */
+    readonly width?: number;
+}
+export interface Reaction {
+    readonly id: string;
+    readonly reactants: readonly SpeciesAmount[];
+    readonly products: readonly SpeciesAmount[];
+    readonly kinetics: Kinetics;
+    readonly kind: ReactionKind;
+    readonly gates?: ReactionGates;
+}
+/**
+ * A phase change, as the reaction it actually is.
+ *
+ * **Its enthalpy is not given here and must not be**: Hess's law over CH-0's formation enthalpies
+ * gives 333,611 J/kg for ice melting against a literature 333,550, and — the part that settles the
+ * design — 2,442,631 J/kg for water boiling, which is the value **at 298.15 K** rather than the
+ * 2,256,400 quoted at the boiling point. That is right, and it means the latent heat at any
+ * temperature stops being stored and becomes a consequence of the heat capacities either side,
+ * varying the way the real one does.
+ *
+ * **A fast finite rate rather than `Instant`, and the difference is the whole plateau.** Instant
+ * kinetics would let the clamp convert every gram of water it could reach in a single sub-step —
+ * two and a half megajoules absorbed at once, and a temperature that falls hundreds of kelvin below
+ * the boiling point rather than sitting on it. A finite rate through an opening gate is a
+ * proportional controller instead: the further above the transition the temperature strays, the
+ * more converts, the more heat is absorbed, and it settles just above with an overshoot
+ * proportional to the flux arriving. That settling *is* the plateau, and it comes out of the
+ * substep-and-clamp solver rather than out of a table.
+ *
+ * `activationEnergy: 0` makes the Arrhenius form a constant, so no second kinetics kind was needed.
+ */
+export declare function phaseChange(id: string, from: string, to: string, temperature: number, width?: number, rate?: number): Reaction;
+/**
+ * A phase change the other way up: the one that runs as something *cools*.
+ *
+ * **`phaseChange` is "heat arrives" and this is "heat leaves", and the pair is not symmetric by
+ * accident.** Everything the library had until now was the first kind — ice melts, water boils, wax
+ * vaporises — because a fire is heat arriving. A vapour condensing is the same mechanism read
+ * backwards: it runs *below* a temperature rather than above one, its gate closes as the
+ * temperature rises through the transition, and its enthalpy comes out with the opposite sign
+ * because Hess's law over the two species already carries it.
+ *
+ * **The gate closes over `width` rather than snapping**, and `gateOpening` grew the upper taper for
+ * this. Without it the pair rings: the temperature falls through the transition, the gate opens
+ * fully, latent heat is released, the temperature rises back through it, and the gate slams. That
+ * is `PHASE_GATE_WIDTH`'s argument with the signs reversed, so it takes the same answer.
+ *
+ * **A condensation wants a reverse reaction and its caller must write one.** Nothing here pairs
+ * them, because a pair is two entries in a network and the network is data. A condensation with no
+ * evaporation is a one-way sink: droplets that drift back into a flame stay droplets, and the smoke
+ * over a fire never turns black again.
+ */
+export declare function condensation(id: string, from: string, to: string, temperature: number, width?: number, rate?: number): Reaction;
+/**
+ * How fast a phase change runs with its gate fully open, per second.
+ *
+ * **A gain, not a physical constant, and it is bounded from both sides.** Too high and one step
+ * converts more than the arriving heat can pay for, so the temperature undershoots and the pair
+ * rings. Too low and the phase change cannot keep up with a real flux — at this value a kilogram
+ * boils at up to half a gram a second per kelvin of overshoot, which is about 1.2 kW and rises with
+ * the overshoot, so a kettle settles a thousandth of a kelvin above its boiling point and a blowtorch
+ * settles further above it. That the band widens with the flux is correct rather than a compromise.
+ */
+export declare const PHASE_RATE = 0.5;
+/**
+ * K over which a phase change's gate opens, for a pure substance.
+ *
+ * Not zero, and that is what keeps the plateau a plateau rather than a sawtooth: a gate that snapped
+ * fully open a hair above the transition would convert far more than the arriving heat can pay for,
+ * undershoot, snap shut, and ring. Half a kelvin is the band the temperature is then held within.
+ */
+export declare const PHASE_GATE_WIDTH = 0.5;

package/dist/reaction/reaction.js

@@ -0,0 +1,104 @@
+/**
+ * What a reaction is: stoichiometry, a rate law, and what kind of change it represents.
+ *
+ * **No enthalpy field**, and that is the same decision `SpeciesDefinition` makes about molar mass.
+ * A reaction's `ΔH` is derived from its species' formation enthalpies by Hess's law at
+ * registration, so a number that disagreed with its own species cannot exist. `§5` of the design is
+ * the argument, and CH-0's heating-value test is what makes the underlying numbers trustworthy.
+ *
+ * **No gates yet.** The design's `ReactionGates` — a minimum oxygen fraction, a phase requirement,
+ * a moisture ceiling — are refused in this phase rather than stubbed: an oxygen gate without a gas
+ * field to read is a constant pretending to be physics, and the field is CH-4. The network here
+ * runs on mass action alone.
+ */
+export const KIND_DRYING = 0;
+export const KIND_PYROLYSIS = 1;
+export const KIND_COMBUSTION = 2;
+export const KIND_CHAR_OXIDATION = 3;
+export const KIND_CALCINATION = 4;
+export const KIND_CORROSION = 5;
+export const KIND_DISSOLUTION = 6;
+export const KIND_DENATURATION = 7;
+export const KIND_BROWNING = 8;
+export const KIND_BIOLOGICAL = 9;
+export const KIND_PHASE_CHANGE = 10;
+/**
+ * A phase change, as the reaction it actually is.
+ *
+ * **Its enthalpy is not given here and must not be**: Hess's law over CH-0's formation enthalpies
+ * gives 333,611 J/kg for ice melting against a literature 333,550, and — the part that settles the
+ * design — 2,442,631 J/kg for water boiling, which is the value **at 298.15 K** rather than the
+ * 2,256,400 quoted at the boiling point. That is right, and it means the latent heat at any
+ * temperature stops being stored and becomes a consequence of the heat capacities either side,
+ * varying the way the real one does.
+ *
+ * **A fast finite rate rather than `Instant`, and the difference is the whole plateau.** Instant
+ * kinetics would let the clamp convert every gram of water it could reach in a single sub-step —
+ * two and a half megajoules absorbed at once, and a temperature that falls hundreds of kelvin below
+ * the boiling point rather than sitting on it. A finite rate through an opening gate is a
+ * proportional controller instead: the further above the transition the temperature strays, the
+ * more converts, the more heat is absorbed, and it settles just above with an overshoot
+ * proportional to the flux arriving. That settling *is* the plateau, and it comes out of the
+ * substep-and-clamp solver rather than out of a table.
+ *
+ * `activationEnergy: 0` makes the Arrhenius form a constant, so no second kinetics kind was needed.
+ */
+export function phaseChange(id, from, to, temperature, width = PHASE_GATE_WIDTH, rate = PHASE_RATE) {
+    return {
+        id,
+        reactants: [{ species: from, moles: 1 }],
+        products: [{ species: to, moles: 1 }],
+        kinetics: { type: 'arrhenius', A: rate, activationEnergy: 0 },
+        kind: KIND_PHASE_CHANGE,
+        gates: { minTemperature: temperature, width },
+    };
+}
+/**
+ * A phase change the other way up: the one that runs as something *cools*.
+ *
+ * **`phaseChange` is "heat arrives" and this is "heat leaves", and the pair is not symmetric by
+ * accident.** Everything the library had until now was the first kind — ice melts, water boils, wax
+ * vaporises — because a fire is heat arriving. A vapour condensing is the same mechanism read
+ * backwards: it runs *below* a temperature rather than above one, its gate closes as the
+ * temperature rises through the transition, and its enthalpy comes out with the opposite sign
+ * because Hess's law over the two species already carries it.
+ *
+ * **The gate closes over `width` rather than snapping**, and `gateOpening` grew the upper taper for
+ * this. Without it the pair rings: the temperature falls through the transition, the gate opens
+ * fully, latent heat is released, the temperature rises back through it, and the gate slams. That
+ * is `PHASE_GATE_WIDTH`'s argument with the signs reversed, so it takes the same answer.
+ *
+ * **A condensation wants a reverse reaction and its caller must write one.** Nothing here pairs
+ * them, because a pair is two entries in a network and the network is data. A condensation with no
+ * evaporation is a one-way sink: droplets that drift back into a flame stay droplets, and the smoke
+ * over a fire never turns black again.
+ */
+export function condensation(id, from, to, temperature, width = PHASE_GATE_WIDTH, rate = PHASE_RATE) {
+    return {
+        id,
+        reactants: [{ species: from, moles: 1 }],
+        products: [{ species: to, moles: 1 }],
+        kinetics: { type: 'arrhenius', A: rate, activationEnergy: 0 },
+        kind: KIND_PHASE_CHANGE,
+        gates: { maxTemperature: temperature, width },
+    };
+}
+/**
+ * How fast a phase change runs with its gate fully open, per second.
+ *
+ * **A gain, not a physical constant, and it is bounded from both sides.** Too high and one step
+ * converts more than the arriving heat can pay for, so the temperature undershoots and the pair
+ * rings. Too low and the phase change cannot keep up with a real flux — at this value a kilogram
+ * boils at up to half a gram a second per kelvin of overshoot, which is about 1.2 kW and rises with
+ * the overshoot, so a kettle settles a thousandth of a kelvin above its boiling point and a blowtorch
+ * settles further above it. That the band widens with the flux is correct rather than a compromise.
+ */
+export const PHASE_RATE = 0.5;
+/**
+ * K over which a phase change's gate opens, for a pure substance.
+ *
+ * Not zero, and that is what keeps the plateau a plateau rather than a sawtooth: a gate that snapped
+ * fully open a hair above the transition would convert far more than the arriving heat can pay for,
+ * undershoot, snap shut, and ring. Half a kelvin is the band the temperature is then held within.
+ */
+export const PHASE_GATE_WIDTH = 0.5;

package/dist/reaction/registry.d.ts

@@ -0,0 +1,47 @@
+import type { SpeciesRegistry } from '../species/registry.ts';
+import { type RateTable } from './rates.ts';
+import type { Reaction, ReactionKind } from './reaction.ts';
+export * from './reaction.ts';
+export declare class ReactionRegistry {
+    private readonly species;
+    private readonly ids;
+    private readonly byId;
+    private readonly kinds;
+    private readonly gateMin;
+    private readonly gateMax;
+    private readonly gateWidth;
+    private readonly transport;
+    private readonly enthalpies;
+    private readonly tables;
+    private readonly reactantIndex;
+    private readonly reactantAmount;
+    private readonly productIndex;
+    private readonly productAmount;
+    private readonly balance;
+    constructor(species: SpeciesRegistry);
+    get count(): number;
+    register(reaction: Reaction): number;
+    indexOf(id: string): number;
+    idOf(reaction: number): string;
+    kindOf(reaction: number): ReactionKind;
+    /** J per unit extent. Negative releases heat; positive absorbs it. */
+    enthalpyOf(reaction: number): number;
+    rateTableOf(reaction: number): RateTable;
+    /** K below which this reaction does not run at all. */
+    minTemperatureOf(reaction: number): number;
+    /** K above which it does not run at all. */
+    maxTemperatureOf(reaction: number): number;
+    /** K over which the lower gate opens rather than snapping. */
+    gateWidthOf(reaction: number): number;
+    /** The ceiling transport puts on this reaction in still air, per second. Zero means none. */
+    transportLimitOf(reaction: number): number;
+    /** The table, or `null` where the reaction is instant. What the localiser packs. */
+    rateTableOrNull(reaction: number): RateTable | null;
+    /** The rate constant at a temperature. An instant reaction answers with a very large number. */
+    rateOf(reaction: number, temperature: number): number;
+    reactantSpecies(reaction: number): Int32Array;
+    reactantMoles(reaction: number): Float64Array;
+    productSpecies(reaction: number): Int32Array;
+    productMoles(reaction: number): Float64Array;
+    private check;
+}

package/dist/reaction/registry.js

@@ -0,0 +1,215 @@
+/**
+ * The reactions a world knows about, balanced and costed at registration.
+ *
+ * Two things happen here that cannot happen later, and both are refusals rather than warnings.
+ *
+ * **Every reaction is checked against the element matrix**, and one that does not balance is
+ * refused naming the element and the size of the gap. An unbalanced reaction invents or destroys
+ * matter every time it runs, and every symptom of that is subtle — a fire that will not go out, a
+ * mass that quietly grows, smoke that never clears. CH-0 built the matrix for exactly this moment.
+ *
+ * **Every reaction's enthalpy is derived by Hess's law** from the formation enthalpies CH-0 stores,
+ * rather than typed in. A `ΔH` that disagreed with its own species would conserve energy in the
+ * code and lose it against the world, with nothing to detect it. Derived, the two cannot disagree,
+ * and a wrong formation enthalpy shows up in every reaction that touches the species at once —
+ * which is a bug that can be found.
+ */
+import { ELEMENT_COUNT, ELEMENTS } from '../element/elements.js';
+import { tabulateArrhenius, tabulateCardinal } from './rates.js';
+export * from './reaction.js';
+/** How far a reaction may be from balancing, in moles of an element per unit extent. */
+const BALANCE_TOLERANCE = 1e-9;
+/** `instant` has no table; the solver's clamp is what bounds it. A huge constant stands in. */
+const INSTANT_RATE = 1e12;
+export class ReactionRegistry {
+    species;
+    ids = [];
+    byId = new Map();
+    kinds = [];
+    gateMin = [];
+    gateMax = [];
+    gateWidth = [];
+    transport = [];
+    enthalpies = [];
+    tables = [];
+    reactantIndex = [];
+    reactantAmount = [];
+    productIndex = [];
+    productAmount = [];
+    /* Scratch for the balance check. Registration-time, so this is tidiness rather than a hot path. */
+    balance = new Float64Array(ELEMENT_COUNT);
+    constructor(species) {
+        this.species = species;
+    }
+    get count() {
+        return this.ids.length;
+    }
+    register(reaction) {
+        const { id } = reaction;
+        if (this.byId.has(id))
+            throw new Error(`reaction "${id}" is already registered`);
+        if (reaction.reactants.length === 0)
+            throw new Error(`reaction "${id}" has no reactants`);
+        if (reaction.products.length === 0)
+            throw new Error(`reaction "${id}" has no products`);
+        const resolve = (side, what) => {
+            const index = new Int32Array(side.length);
+            const amount = new Float64Array(side.length);
+            for (let i = 0; i < side.length; i++) {
+                const entry = side[i];
+                const at = this.species.indexOf(entry.species);
+                if (at < 0) {
+                    throw new Error(`reaction "${id}" names ${what} "${entry.species}", which is not a registered species`);
+                }
+                if (!Number.isFinite(entry.moles) || entry.moles <= 0) {
+                    throw new Error(`reaction "${id}" gives ${what} "${entry.species}" a coefficient of ${entry.moles}`);
+                }
+                index[i] = at;
+                amount[i] = entry.moles;
+            }
+            return [index, amount];
+        };
+        const [reactantIndex, reactantAmount] = resolve(reaction.reactants, 'reactant');
+        const [productIndex, productAmount] = resolve(reaction.products, 'product');
+        /* Products minus reactants, element by element. Zero everywhere or it does not run. */
+        this.balance.fill(0);
+        for (let i = 0; i < productIndex.length; i++) {
+            this.species.elements.addScaledRow(productIndex[i], productAmount[i], this.balance);
+        }
+        for (let i = 0; i < reactantIndex.length; i++) {
+            this.species.elements.addScaledRow(reactantIndex[i], -reactantAmount[i], this.balance);
+        }
+        for (let e = 0; e < ELEMENT_COUNT; e++) {
+            const gap = this.balance[e];
+            if (Math.abs(gap) > BALANCE_TOLERANCE) {
+                const side = gap > 0 ? 'more' : 'less';
+                throw new Error(`reaction "${id}" does not balance: its products hold ${Math.abs(gap)} mol ${side} ` +
+                    `${ELEMENTS[e]} than its reactants`);
+            }
+        }
+        /* Hess's law: the products' formation enthalpies less the reactants'. */
+        let enthalpy = 0;
+        for (let i = 0; i < productIndex.length; i++) {
+            enthalpy +=
+                productAmount[i] * this.species.formationEnthalpyOf(productIndex[i]);
+        }
+        for (let i = 0; i < reactantIndex.length; i++) {
+            enthalpy -=
+                reactantAmount[i] *
+                    this.species.formationEnthalpyOf(reactantIndex[i]);
+        }
+        const kinetics = reaction.kinetics;
+        let table;
+        let transportLimit = 0;
+        switch (kinetics.type) {
+            case 'arrhenius':
+                table = tabulateArrhenius(kinetics.A, kinetics.activationEnergy, kinetics.n ?? 0);
+                break;
+            case 'diffusion':
+                table = tabulateArrhenius(kinetics.A, kinetics.activationEnergy, kinetics.n ?? 0);
+                transportLimit = kinetics.transportLimit;
+                if (!(transportLimit > 0)) {
+                    throw new Error(`reaction "${id}" is transport-limited at ${transportLimit} per second`);
+                }
+                break;
+            case 'cardinal':
+                table = tabulateCardinal(kinetics.peak, kinetics.minimum, kinetics.optimum, kinetics.maximum);
+                break;
+            case 'instant':
+                table = null;
+                break;
+        }
+        const index = this.ids.length;
+        this.ids.push(id);
+        this.byId.set(id, index);
+        this.kinds.push(reaction.kind);
+        const gates = reaction.gates;
+        this.gateMin.push(gates?.minTemperature ?? Number.NEGATIVE_INFINITY);
+        this.gateMax.push(gates?.maxTemperature ?? Number.POSITIVE_INFINITY);
+        this.gateWidth.push(gates?.width ?? 0);
+        this.enthalpies.push(enthalpy);
+        this.tables.push(table);
+        this.transport.push(transportLimit);
+        this.reactantIndex.push(reactantIndex);
+        this.reactantAmount.push(reactantAmount);
+        this.productIndex.push(productIndex);
+        this.productAmount.push(productAmount);
+        return index;
+    }
+    indexOf(id) {
+        return this.byId.get(id) ?? -1;
+    }
+    idOf(reaction) {
+        return this.ids[this.check(reaction)];
+    }
+    kindOf(reaction) {
+        return this.kinds[this.check(reaction)];
+    }
+    /** J per unit extent. Negative releases heat; positive absorbs it. */
+    enthalpyOf(reaction) {
+        return this.enthalpies[this.check(reaction)];
+    }
+    rateTableOf(reaction) {
+        const table = this.tables[this.check(reaction)];
+        if (table === null) {
+            throw new Error(`reaction "${this.ids[reaction]}" is instant and has no rate table`);
+        }
+        return table;
+    }
+    /** K below which this reaction does not run at all. */
+    minTemperatureOf(reaction) {
+        return this.gateMin[this.check(reaction)];
+    }
+    /** K above which it does not run at all. */
+    maxTemperatureOf(reaction) {
+        return this.gateMax[this.check(reaction)];
+    }
+    /** K over which the lower gate opens rather than snapping. */
+    gateWidthOf(reaction) {
+        return this.gateWidth[this.check(reaction)];
+    }
+    /** The ceiling transport puts on this reaction in still air, per second. Zero means none. */
+    transportLimitOf(reaction) {
+        return this.transport[this.check(reaction)];
+    }
+    /** The table, or `null` where the reaction is instant. What the localiser packs. */
+    rateTableOrNull(reaction) {
+        return this.tables[this.check(reaction)];
+    }
+    /** The rate constant at a temperature. An instant reaction answers with a very large number. */
+    rateOf(reaction, temperature) {
+        const table = this.tables[this.check(reaction)];
+        if (table === null)
+            return INSTANT_RATE;
+        if (temperature <= table.minTemperature)
+            return table.rate[table.knots - 1];
+        if (temperature >= table.maxTemperature)
+            return table.rate[0];
+        const position = ((1 / temperature - table.inverseMin) / (table.inverseMax - table.inverseMin)) *
+            (table.knots - 1);
+        const low = Math.floor(position);
+        const high = low + 1;
+        if (high >= table.knots)
+            return table.rate[table.knots - 1];
+        const at = position - low;
+        return table.rate[low] * (1 - at) + table.rate[high] * at;
+    }
+    reactantSpecies(reaction) {
+        return this.reactantIndex[this.check(reaction)];
+    }
+    reactantMoles(reaction) {
+        return this.reactantAmount[this.check(reaction)];
+    }
+    productSpecies(reaction) {
+        return this.productIndex[this.check(reaction)];
+    }
+    productMoles(reaction) {
+        return this.productAmount[this.check(reaction)];
+    }
+    check(reaction) {
+        if (!Number.isInteger(reaction) || reaction < 0 || reaction >= this.ids.length) {
+            throw new Error(`reaction ${reaction} is outside a registry of ${this.ids.length}`);
+        }
+        return reaction;
+    }
+}