@driftengine/chemistry 3.61.0

package/dist/element/matrix.js

@@ -0,0 +1,80 @@
+/**
+ * Moles of each element per mole of each species, as one growable table.
+ *
+ * This is the law `§6` of the design rests on. A reaction balances when the sum of its reactants'
+ * rows equals the sum of its products'; a world conserves matter when the sum of every parcel's
+ * composition through this table is constant. Both are one reduction over one `Float64Array`, and
+ * that is only true because `ELEMENT_COUNT` is fixed and the storage is dense.
+ *
+ * **Dense rather than sparse, and it is not close.** Sixty species over fifteen elements is 900
+ * doubles, or 7.2 KB. A sparse structure would save perhaps two thirds of that and cost an
+ * indirection in the innermost loop of every conservation check. The dense table is smaller than
+ * one texture tile.
+ *
+ * Row-major, species-major: a species' fifteen elements are adjacent, because every consumer of
+ * this table walks one species at a time.
+ */
+import { ELEMENT_COUNT } from './elements.js';
+/** Rows the table holds before its first growth. Doubles from here. */
+const INITIAL_ROWS = 64;
+export class SpeciesElementMatrix {
+    store = new Float64Array(INITIAL_ROWS * ELEMENT_COUNT);
+    used = 0;
+    get rows() {
+        return this.used;
+    }
+    /** Append a zeroed row and return its index. */
+    addRow() {
+        if ((this.used + 1) * ELEMENT_COUNT > this.store.length) {
+            const grown = new Float64Array(this.store.length * 2);
+            grown.set(this.store);
+            this.store = grown;
+        }
+        return this.used++;
+    }
+    set(row, element, moles) {
+        this.check(row, element);
+        this.store[row * ELEMENT_COUNT + element] = moles;
+    }
+    at(row, element) {
+        this.check(row, element);
+        return this.store[row * ELEMENT_COUNT + element];
+    }
+    /**
+     * A row as a view of fifteen, sharing storage rather than copying.
+     *
+     * **A view is invalidated by a later `addRow` that grows the table**, because growth reallocates.
+     * Every caller in this package takes a view inside a loop that registers nothing, which is the
+     * only safe pattern and is why this is not handed out as a promise.
+     */
+    rowView(row) {
+        this.check(row, 0);
+        return this.store.subarray(row * ELEMENT_COUNT, (row + 1) * ELEMENT_COUNT);
+    }
+    /**
+     * `out[e] += scale * this[row][e]`, for all fifteen. Allocates nothing.
+     *
+     * The primitive every conservation check is built from, and it exists rather than a loop over
+     * `at` for one reason: `rowView` would be the natural way to write that loop and `subarray`
+     * allocates a view object per call, which is an allocation per species per tick. It adds rather
+     * than replaces so a caller sums a whole world into one vector without a second accumulator.
+     */
+    addScaledRow(row, scale, out) {
+        this.check(row, 0);
+        if (out.length !== ELEMENT_COUNT) {
+            throw new Error(`a totals vector is ${ELEMENT_COUNT} wide, not ${out.length}`);
+        }
+        const base = row * ELEMENT_COUNT;
+        for (let e = 0; e < ELEMENT_COUNT; e++) {
+            out[e] = out[e] + scale * this.store[base + e];
+        }
+    }
+    check(row, element) {
+        if (!Number.isInteger(row) || row < 0 || row >= this.used) {
+            throw new Error(`species row ${row} is outside a matrix of ${this.used}`);
+        }
+        if (!Number.isInteger(element) || element < 0 || element >= ELEMENT_COUNT) {
+            throw new Error(`element ${element} is outside the set of ${ELEMENT_COUNT}`);
+        }
+    }
+}

package/dist/field/ambient.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The far field: what the air is where nothing has happened to it.
+ *
+ * A consumer's constant, and everything downstream adjusts to it without a feature. A low-oxygen
+ * atmosphere makes fire hard to start and easy to put out; a high-oxygen one makes everything
+ * terrifying; a thin one lowers every boiling point in the world. None of those needed code.
+ */
+import type { SpeciesRegistry } from '../species/registry.ts';
+/** Pa. */
+export declare const STANDARD_PRESSURE_PA = 101325;
+/** J/(mol·K). */
+export declare const GAS_CONSTANT = 8.314462618;
+export interface AmbientState {
+    readonly temperature: number;
+    readonly pressure: number;
+    /** Relative humidity, 0..1. Added to the dry composition when a cell is filled. */
+    readonly humidity: number;
+    /** Dry mass fractions over gas species, summing to one. */
+    readonly composition: Readonly<Record<string, number>>;
+}
+/**
+ * Dry air at 20 °C and one atmosphere, at 50% relative humidity.
+ *
+ * **Argon is lumped into nitrogen**, per the species table's own note: it is 0.93% of air and
+ * chemically inert, so all it contributes is heat capacity and dilution. What that costs is
+ * measurable and small — the mean molar mass comes out at 28.86 g/mol against air's real 28.96,
+ * which is 0.4% — and what it buys is not carrying a sixteenth element for a gas that never reacts.
+ *
+ * The mass fractions are chosen so the *volume* fraction of oxygen comes back at 20.95%, because
+ * that is the number every extinction criterion in `§12` is written against.
+ */
+export declare const STANDARD_AIR: AmbientState;
+/** The gas species a field tracks unless a consumer names its own. */
+export declare const STANDARD_FIELD_SPECIES: readonly string[];
+/**
+ * Saturation vapour pressure of water, Pa, by the Magnus form.
+ *
+ * Authoring-time: it calls `exp`, and `§7` keeps transcendentals off the tick. A field fills a new
+ * cell from the ambient, which is a discrete event rather than a per-tick one, and CH-5's
+ * evaporation will need this tabulated the way every rate already is.
+ */
+export declare function saturationVapourPressure(temperature: number): number;
+/**
+ * Mass of each tracked species in one cell of ambient air, kg.
+ *
+ * From the ideal gas law at the ambient temperature and pressure, with the humidity turned into
+ * water vapour by its partial pressure. Writes into `out`, one entry per field species.
+ */
+export declare function ambientCellMass(registry: SpeciesRegistry, fieldSpecies: Int32Array, ambient: AmbientState, volume: number, out: Float64Array): void;

package/dist/field/ambient.js

@@ -0,0 +1,82 @@
+/** Pa. */
+export const STANDARD_PRESSURE_PA = 101325;
+/** J/(mol·K). */
+export const GAS_CONSTANT = 8.314462618;
+/**
+ * Dry air at 20 °C and one atmosphere, at 50% relative humidity.
+ *
+ * **Argon is lumped into nitrogen**, per the species table's own note: it is 0.93% of air and
+ * chemically inert, so all it contributes is heat capacity and dilution. What that costs is
+ * measurable and small — the mean molar mass comes out at 28.86 g/mol against air's real 28.96,
+ * which is 0.4% — and what it buys is not carrying a sixteenth element for a gas that never reacts.
+ *
+ * The mass fractions are chosen so the *volume* fraction of oxygen comes back at 20.95%, because
+ * that is the number every extinction criterion in `§12` is written against.
+ */
+export const STANDARD_AIR = {
+    temperature: 293.15,
+    pressure: STANDARD_PRESSURE_PA,
+    humidity: 0.5,
+    composition: { N2: 0.767074, O2: 0.232285, CO2: 0.000641 },
+};
+/** The gas species a field tracks unless a consumer names its own. */
+export const STANDARD_FIELD_SPECIES = [
+    'O2',
+    'N2',
+    'CO2',
+    'H2O(g)',
+    'CO',
+    'CH4',
+    'H2',
+    'C2H4',
+    'NH3',
+    'HCN',
+    'HCl',
+    'SO2',
+];
+/**
+ * Saturation vapour pressure of water, Pa, by the Magnus form.
+ *
+ * Authoring-time: it calls `exp`, and `§7` keeps transcendentals off the tick. A field fills a new
+ * cell from the ambient, which is a discrete event rather than a per-tick one, and CH-5's
+ * evaporation will need this tabulated the way every rate already is.
+ */
+export function saturationVapourPressure(temperature) {
+    const celsius = temperature - 273.15;
+    // determinism: build-time — a field fills a new cell from the ambient, which is a discrete event
+    return 610.94 * Math.exp((17.625 * celsius) / (celsius + 243.04));
+}
+/**
+ * Mass of each tracked species in one cell of ambient air, kg.
+ *
+ * From the ideal gas law at the ambient temperature and pressure, with the humidity turned into
+ * water vapour by its partial pressure. Writes into `out`, one entry per field species.
+ */
+export function ambientCellMass(registry, fieldSpecies, ambient, volume, out) {
+    const vapourPressure = ambient.humidity * saturationVapourPressure(ambient.temperature);
+    const dryPressure = Math.max(0, ambient.pressure - vapourPressure);
+    const totalMoles = (ambient.pressure * volume) / (GAS_CONSTANT * ambient.temperature);
+    const vapourMoles = (vapourPressure * volume) / (GAS_CONSTANT * ambient.temperature);
+    const dryMoles = totalMoles - vapourMoles;
+    /* The dry composition is by mass, so its mean molar mass is what converts moles to kilograms. */
+    let inverseMean = 0;
+    for (const [id, fraction] of Object.entries(ambient.composition)) {
+        const species = registry.indexOf(id);
+        if (species < 0)
+            throw new Error(`ambient names "${id}", which is not a registered species`);
+        inverseMean += fraction / registry.molarMass(species);
+    }
+    const meanMolarMass = 1 / inverseMean;
+    const dryMass = dryMoles * meanMolarMass;
+    out.fill(0);
+    for (let i = 0; i < fieldSpecies.length; i++) {
+        const id = registry.idOf(fieldSpecies[i]);
+        const fraction = ambient.composition[id];
+        if (fraction !== undefined)
+            out[i] = fraction * dryMass;
+        if (id === 'H2O(g)') {
+            out[i] = out[i] + vapourMoles * registry.molarMass(fieldSpecies[i]);
+        }
+    }
+    void dryPressure;
+}

package/dist/field/atmosphere.d.ts

@@ -0,0 +1,308 @@
+import type { SpeciesRegistry } from '../species/registry.ts';
+import type { ReactionRegistry } from '../reaction/registry.ts';
+import { type AmbientState } from './ambient.ts';
+/** Cells along one edge of a chunk. */
+export declare const CHUNK_CELLS = 8;
+/** Metres along one edge of a chunk, at the default cell size. */
+export declare const CHUNK_SIZE = 8;
+export interface AtmosphereOptions {
+    /** Metres per cell. One by default, which makes a chunk eight metres across. */
+    readonly cellSize?: number;
+    readonly ambient?: AmbientState;
+    /** Gas species to track. Twelve by default; a consumer may name fewer and pay less. */
+    readonly species?: readonly string[];
+    /**
+     * How many chunks the live set may grow to before its edge becomes far field.
+     *
+     * A plume growing the live set is correct — smoke really does reach new ground — and unbounded
+     * growth is not. Past the cap a boundary face vents to the ambient instead of creating a
+     * neighbour, which degrades a plume into a dissipating one rather than failing.
+     */
+    readonly maxChunks?: number;
+    /** How fast an open boundary equalises with the far field, per second. */
+    readonly openness?: number;
+    /** Diffusivity between neighbouring cells, m²/s. */
+    readonly diffusivity?: number;
+    /** Where `reactionIds` are looked up. */
+    readonly reactions?: ReactionRegistry;
+    /**
+     * Gas-phase reactions to run in every cell, by id.
+     *
+     * `§8.4`'s combustion, and it is **not a second implementation** of the solver a shell uses — it
+     * is that one, given a cell. Which is what makes a flame stand off a surface rather than sit on
+     * it: burning is something the *air* does, in the place where the mixture is right.
+     */
+    readonly reactionIds?: readonly string[];
+}
+export declare class AtmosphereField {
+    private readonly registry;
+    readonly cellSize: number;
+    readonly cellVolume: number;
+    readonly ambient: AmbientState;
+    /** Global species indices this field tracks, in storage order. */
+    readonly species: Int32Array;
+    /** kg per species per cell, then one enthalpy per cell, then soot and aerosol. */
+    private readonly chunks;
+    private readonly blocked;
+    private readonly coords;
+    private readonly byKey;
+    /** Each chunk's packed `key(cx, cy, cz)`, parallel to `chunks`. */
+    private readonly keys;
+    /**
+     * Chunk indices in **key order**, which is the order every sweep and every reduction walks.
+     *
+     * **`chunks` is in creation order and creation order is history.** Two runs of one world that
+     * realise their chunks in a different sequence — a consumer spawning two logs the other way round
+     * is enough — hold identical per-cell state in differently-ordered arrays, and every `+=` over
+     * them then lands in a different order. Floating-point addition is not associative, so the answer
+     * differs in the last bit, and `fingerprintChemistry` reports a divergence that did not happen.
+     *
+     * Worse than the report: the sweep accumulates into shared `deltas`, so the *state* diverges too
+     * and a stiff exponential rate law grows the difference. Measured before this existed: two logs
+     * eight metres apart, spawned in the other order, left **1,202 cells** differing after sixty
+     * ticks.
+     *
+     * `key` is a pure function of the chunk's coordinates, so this order is a fact about geometry and
+     * nothing else. Maintained by insertion at creation, which is rare; the sweeps pay one indirection
+     * per chunk, not per cell.
+     */
+    private readonly order;
+    /** Scratch for one sweep round, so the walk does not observe chunks created during it. */
+    private round;
+    /** Which sweep last visited each chunk, so a chunk created mid-sweep is swept exactly once. */
+    private readonly sweptAt;
+    private pass;
+    private readonly stride;
+    private readonly enthalpySlot;
+    private readonly sootSlot;
+    private readonly aerosolSlot;
+    /** Where `C(soot)` sits among the tracked species, or -1 where this field does not carry it. */
+    private readonly sootSpecies;
+    /** Slots of every carried species in the liquid phase: droplets, which is what an aerosol is. */
+    private readonly aerosolSpecies;
+    /** One cell of untouched air, filled once and copied into every new cell. */
+    readonly maxChunks: number;
+    private readonly openness;
+    private readonly diffusivity;
+    /** Deltas for one step, so no cell sees a neighbour a previous cell already changed. */
+    private readonly deltas;
+    /** What has left through an open boundary: per species, then enthalpy, soot and aerosol. */
+    private readonly vented;
+    private ventedEnthalpyTotal;
+    private readonly ambientCell;
+    private readonly ambientEnthalpy;
+    private readonly ambientMass;
+    /**
+     * The ambient temperature **as `cellTemperature` computes it**, not as it was authored.
+     *
+     * The same arithmetic over the same doubles in the same order, so a cell that has been realised
+     * and one that has not report the identical number. See `temperatureAt`.
+     */
+    private readonly ambientTemperatureExact;
+    /** `saturationVapourPressure` sampled once, so `exp` never runs on a query. */
+    private readonly saturationTable;
+    private readonly network;
+    private readonly combustible;
+    private readonly molarMass;
+    /** J/(kg·K) at the standard state, one per tracked species. Resolved once. */
+    private readonly heatCapacity;
+    private readonly localOf;
+    constructor(registry: SpeciesRegistry, options?: AtmosphereOptions);
+    get chunkCount(): number;
+    /** How many species this field tracks. */
+    get speciesCount(): number;
+    /** The local slot a global species occupies, or -1. */
+    slotOf(species: number): number;
+    private key;
+    /** The chunk holding a point, creating it if `create`. `-1` where none exists. */
+    private chunkAt;
+    private createChunk;
+    /** Index of the cell containing a point within its chunk. */
+    private cellIn;
+    /** The base offset of the cell containing a point, or `-1` where no chunk exists. */
+    private baseAt;
+    private dataAt;
+    /** Add (or with a negative value, remove) mass of one species at a point. */
+    addSpecies(x: number, y: number, z: number, species: number, kilograms: number): void;
+    addHeat(x: number, y: number, z: number, joules: number): void;
+    addSoot(x: number, y: number, z: number, kilograms: number): void;
+    addAerosol(x: number, y: number, z: number, kilograms: number): void;
+    /** Mark a cell as occupied by geometry. A blocked face transports nothing. */
+    setBlocked(x: number, y: number, z: number, blocked: boolean): void;
+    isBlocked(x: number, y: number, z: number): boolean;
+    speciesMassAt(x: number, y: number, z: number, species: number): number;
+    /**
+     * Kilograms of soot in the cell: the `C(soot)` its own chemistry made, plus anything added.
+     *
+     * **Two sources on purpose.** Soot a fire produced is the `C(soot)` *species*, which keeps its
+     * carbon inside `elementTotals` — a channel carrying mass outside the ledger would make the most
+     * valuable assertion in the track quietly wrong every time something smoked. The channel is for a
+     * consumer who wants smoke without chemistry behind it: a smoke grenade, a chimney, a dust cloud.
+     */
+    sootAt(x: number, y: number, z: number): number;
+    /**
+     * Kilograms of suspended droplets in the cell — the pale half of smoke.
+     *
+     * Soot is near-black and a droplet is near-white, so the *ratio* between them is what colours a
+     * plume: `§17` reads it, and a wet fire steams white where a rich one smokes black with neither
+     * being chosen. Symmetric with `sootAt`, and for the same two reasons.
+     *
+     * **Two sources, exactly as soot has.** Anything the chemistry condensed is a *species* — wood tar
+     * coming out of a cooling plume is the case this was built for — so its mass stays inside
+     * `elementTotals` and the most valuable assertion in the track keeps covering it. The channel
+     * `addAerosol` writes is for a consumer who wants steam without a boiler behind it: a kettle
+     * dressed for a scene, a waterfall's spray, a breath on a cold morning.
+     */
+    aerosolAt(x: number, y: number, z: number): number;
+    /**
+     * The upward speed this cell's own lightness gives it, m/s.
+     *
+     * **The field's own number rather than a second one.** `§17` gives a smoke particle its velocity
+     * from "the cell's advected plus buoyant velocity", and this is the buoyant half — the same
+     * function transport uses, so a particle rises at the speed the gas carrying it actually rises at
+     * rather than at a rate chosen to look right.
+     */
+    riseAt(x: number, y: number, z: number): number;
+    /** Total moles of gas in the cell containing a point. */
+    molesAt(x: number, y: number, z: number): number;
+    /** Joules held by the cell containing a point. */
+    enthalpyAt(x: number, y: number, z: number): number;
+    /** kg of gas in the cell containing a point. */
+    massAt(x: number, y: number, z: number): number;
+    /**
+     * K, from the cell's enthalpy and the heat capacity of what is in it.
+     *
+     * A gas mixture has no phase plateau, so this is a division rather than the curve inversion a
+     * parcel needs — and it is evaluated at the standard state's heat capacity, which is where the
+     * mixture's `cp` is anchored.
+     */
+    /**
+     * K of the cell containing a point.
+     *
+     * **`ambientTemperatureExact` rather than `this.ambient.temperature`, and the difference is a
+     * determinism bug rather than a rounding nicety.** A cell nobody has touched is not stored; one a
+     * neighbour realised is. Returning the *authored* 293.15 for the first and the *derived*
+     * 293.15000000000003 for the second made a cell's reported temperature depend on whether some
+     * other parcel had happened to create the chunk first — which put an order dependence into
+     * convection, and from there into whether a log ignites on tick N or tick N+1.
+     *
+     * Found by `world/fingerprint.test.ts`: two logs spawned the other way round diverged in the
+     * eleventh digit on their very first tick, and nothing about them was different.
+     */
+    temperatureAt(x: number, y: number, z: number): number;
+    private cellTemperature;
+    /** Volume fraction of one species, which for a gas is its mole fraction. */
+    volumeFractionAt(x: number, y: number, z: number, species: number): number;
+    /**
+     * Volume fraction of the cell that is gas which can burn.
+     *
+     * What a flammability limit is checked against. Below the lower limit there is not enough fuel to
+     * carry a flame; above the upper there is not enough air, which is why a fuel-soaked rag smokes
+     * rather than flames until it thins out.
+     */
+    fuelFractionAt(x: number, y: number, z: number): number;
+    oxygenFractionAt(x: number, y: number, z: number): number;
+    /** Parts per million by volume, which is the reading a game acts on. */
+    concentrationAt(x: number, y: number, z: number, species: number): number;
+    /** kg/m³. */
+    densityAt(x: number, y: number, z: number): number;
+    /** Pa, by the ideal gas law over what the cell holds at the temperature it is. */
+    pressureAt(x: number, y: number, z: number): number;
+    /**
+     * How thick the smoke is, as an extinction coefficient in inverse metres.
+     *
+     * **The quantity `visibilityAt` is derived from**, and the one a consumer attenuating a light
+     * along a ray actually needs: metres of visibility is one answer to it and `exp(−σ·d)` is another.
+     * Exporting only the first would have every consumer inverting Koschmieder to get back here.
+     */
+    smokeDensityAt(x: number, y: number, z: number): number;
+    /**
+     * How far you can see, metres.
+     *
+     * Koschmieder over the soot's extinction. Clamped at ten kilometres, past which the answer stops
+     * being about the smoke.
+     */
+    visibilityAt(x: number, y: number, z: number): number;
+    /**
+     * Relative humidity, 0 to 1: the water vapour present against what this air could hold.
+     *
+     * **The reading that decides whether anything dries.** `§8.1`'s evaporation is driven by the
+     * vapour pressure *deficit*, so washing dries in wind and nothing dries in fog — and the same
+     * number is why a fire dries a room out while removing no water at all: warm air could hold more,
+     * so the same vapour is a smaller fraction of saturation.
+     *
+     * **Saturation is tabulated**, per `§7`'s rule, because it is `exp` of a rational function of
+     * temperature and this is a query a script may make every frame. 256 knots over 200-500 K, where
+     * linear interpolation is under a tenth of a percent.
+     */
+    humidityAt(x: number, y: number, z: number): number;
+    /** Pa, off the table `SATURATION_KNOTS` describes. Clamped at both ends rather than extrapolated. */
+    private saturation;
+    /** Kilograms of one species above what the ambient would have held. Diagnostics and tests. */
+    totalAdded(species: number): number;
+    /**
+     * Advance the field one step: expansion, buoyancy, wind, diffusion and the far field.
+     *
+     * **Every transfer is flux-form and conservative** — computed once for a face and applied to both
+     * sides — which is a departure from `§9` worth recording. The design chose semi-Lagrangian
+     * advection for unconditional stability; semi-Lagrangian is **not conservative**, and
+     * conservation is the invariant this whole track is asserted on. Upwind flux has a CFL limit
+     * instead, and a CFL limit is handled here the same way stiffness is handled in the reaction
+     * solver: by sub-stepping. That is the trade taken deliberately.
+     *
+     * **Deltas are accumulated and applied afterwards**, so no cell sees a neighbour that an earlier
+     * cell in the sweep already changed. A Gauss-Seidel sweep would give an answer that depended on
+     * chunk allocation order, which is a determinism hole with no symptom until two runs allocate
+     * differently.
+     *
+     * `windX` and `windZ` come from the one `WindField`, sampled once per frame by the caller.
+     */
+    step(dt: number, windX?: number, windZ?: number): void;
+    /**
+     * Run the gas-phase network in every live cell.
+     *
+     * After transport rather than before, so a cell burns the mixture it actually ended the step
+     * with — which is what makes a flame follow the fuel rather than lag a step behind it.
+     */
+    private react;
+    /** The upward speed a cell's own lightness gives it, m/s. */
+    private buoyantSpeed;
+    /** Resolve a world cell to a packed chunk-and-cell, or -1. */
+    private resolve;
+    private sweep;
+    /** One chunk's faces, for `sweep`. Every transfer lands in `deltas` and is applied afterwards. */
+    private sweepChunk;
+    /**
+     * Whether this cell holds anything the far field would not.
+     *
+     * What bounds the live set. A cell indistinguishable from the outdoors has nothing to spread, so
+     * it never claims a neighbour — which is why a world with one campfire holds the chunks around
+     * that fire rather than a column of air to the sky.
+     */
+    private departsFromAmbient;
+    /** One internal face: bulk transfer by wind, buoyancy and pressure, plus diffusion. */
+    private face;
+    /** A face onto the far field: relax toward ambient and book what crossed. */
+    private ventFace;
+    /** Moles of each element the field holds, over every live chunk. Writes into `out`. */
+    elementTotals(out: Float64Array): void;
+    /** Total gas mass across every live chunk, kg. */
+    totalMass(): number;
+    /** Kilograms of one species that have left through an open boundary. */
+    ventedMass(species: number): number;
+    /** Joules that have left through an open boundary. */
+    ventedEnthalpy(): number;
+    /** Kilograms that have crossed the far-field boundary in total, in either direction. */
+    ventedTotalMass(): number;
+    /**
+     * Moles of each element that have crossed the far-field boundary. Writes into `out`.
+     *
+     * Live chunks alone do not balance, and the reason is not transport: **creating a chunk draws a
+     * chunk of air in from outside**, which is matter appearing in the live set. The ledger records
+     * it, so `elementTotals + ventedElementTotals` is invariant under chunk creation as well as under
+     * everything else — and a conservation assertion over a growing plume is possible at all.
+     */
+    ventedElementTotals(out: Float64Array): void;
+    /** Total enthalpy across every live chunk, J. */
+    totalEnthalpy(): number;
+}