@driftengine/chemistry 3.61.0

package/dist/parcel/store.js

@@ -0,0 +1,1152 @@
+/**
+ * Parcels: lumps of matter with an identity, in structure-of-arrays typed columns.
+ *
+ * A parcel is a log, a steak, a puddle, a wall panel, a barrel of oil. It is **not** a mesh, a body
+ * or an entity — it is bound to one by a handle the consumer keeps, and it knows nothing about what
+ * it is bound to. That is what lets the package import no other engine package.
+ *
+ * **Enthalpy in joules, mass in kilograms, and temperature is neither.** The store holds a total
+ * and the curve holds a specific value, so two kilograms at one temperature hold twice the enthalpy
+ * of one and `temperatureOf` divides before it looks up. Every column is `Float64Array`, per `§15`:
+ * enthalpy differences across a burn span twelve orders of magnitude and `Float32Array` loses the
+ * small ones, which is not an optimisation to revisit later.
+ *
+ * **One lump, one temperature, until CH-2.** The design's parcel has a depth stack of shells, and
+ * without it a thick log heats through as fast as a twig — which is the single most important thing
+ * a fire model has to get right. That is CH-2's, and this store is shaped to grow into it: a shell
+ * is another stride on the enthalpy column and nothing above it changes.
+ *
+ * **A destroyed handle is never reused.** Physics numbers bodies the same way, and reuse without a
+ * generation lets a stale handle address a live parcel. Compaction is a budget question and belongs
+ * with the rest of them in CH-6; until then a destroyed parcel costs its columns and nothing else.
+ */
+import { sensibleEnthalpy, temperatureFromCapacity } from '../species/thermal.js';
+import { conductShells } from './conduction.js';
+import { MAX_SUBSTANCE_SPECIES, reactShell } from '../reaction/solver.js';
+import { ELEMENT_COUNT } from '../element/elements.js';
+import { MAX_SHELLS, shellGeometry } from './shells.js';
+import { TIER_CADENCE, TIER_HERO, TIER_SHELLS, TIER_SUBSTEPS, foldShare, foldSpan, } from './tier.js';
+import { PHASE_GAS, PHASE_LIQUID, PHASE_SOLID } from '../species/species.js';
+/** Parcels held before the first growth. Doubles from here. */
+const INITIAL_CAPACITY = 64;
+/* Scratch for a fold, module-level so a tier change on a hot path allocates nothing. */
+const foldScratch = new Float64Array(MAX_SHELLS * MAX_SUBSTANCE_SPECIES);
+const foldEnthalpy = new Float64Array(MAX_SHELLS);
+/**
+ * A parcel made of more than one phase at once, which is most of them.
+ *
+ * Not a `Phase`, because it is not one: wet wood is a solid and a liquid together, and the design's
+ * `§20.3` gives it its own value rather than making a consumer guess which half was reported.
+ */
+export const PHASE_MIXED = 3;
+/** Share of a parcel's mass one phase must hold before that phase is the answer. */
+const PHASE_DOMINANT = 0.95;
+/** Share of a shell's mass that must be char before the shell counts as charred through. */
+const CHAR_SHELL_FRACTION = 0.5;
+const FLAG_BURNING = 1;
+const FLAG_SMOULDERING = 2;
+const FLAG_PILOT = 4;
+const FLAG_SLEEPING = 8;
+/**
+ * Ticks a parcel must be still for before it sleeps, and how still "still" is.
+ *
+ * `§14`: "a parcel whose net flux is below a threshold, whose composition changed by less than a
+ * threshold last tick, and which has been that way for `N` ticks, sleeps." The counter is what stops
+ * a parcel that is merely between two events from being put to sleep and woken every other tick,
+ * which would cost more than never sleeping it.
+ *
+ * The flux threshold is three orders of magnitude below the critical mass flux at piloted ignition,
+ * so nothing anywhere near catching is ever asleep.
+ */
+const QUIET_TICKS = 30;
+const QUIET_FLUX = 1e-6;
+/** Joules per second of reaction output below which a parcel counts as chemically still. */
+const QUIET_RELEASE = 1e-3;
+export class ParcelStore {
+    substances;
+    species;
+    substance = new Int32Array(INITIAL_CAPACITY);
+    mass = new Float64Array(INITIAL_CAPACITY);
+    /** Strided by `MAX_SHELLS`: shell `s` of parcel `p` is at `p * MAX_SHELLS + s`, in joules. */
+    enthalpy = new Float64Array(INITIAL_CAPACITY * MAX_SHELLS);
+    area = new Float64Array(INITIAL_CAPACITY);
+    x = new Float64Array(INITIAL_CAPACITY);
+    y = new Float64Array(INITIAL_CAPACITY);
+    z = new Float64Array(INITIAL_CAPACITY);
+    live = new Uint8Array(INITIAL_CAPACITY);
+    /** `FLAG_BURNING | FLAG_SMOULDERING | FLAG_PILOT`. */
+    flags = new Uint8Array(INITIAL_CAPACITY);
+    /** kg/(m²·s) of gas leaving the surface, and of the combustible part of it. */
+    flux = new Float64Array(INITIAL_CAPACITY);
+    fuelFlux = new Float64Array(INITIAL_CAPACITY);
+    /**
+     * Watts the reactions put into this parcel over the last `react`, and it is a *readout*.
+     *
+     * **A fire's size is its heat release rate**, not its temperature — every fire-engineering figure
+     * in the design is quoted in kilowatts — and it cannot be recovered from outside, because
+     * conduction and a radiative source change the same enthalpy in the same tick. So it is measured
+     * where only reactions are running, by summing the thermal enthalpy either side of them. That sum
+     * is one pass over at most sixteen shells, which is nothing against the reaction step it brackets.
+     */
+    release = new Float64Array(INITIAL_CAPACITY);
+    /** Which of `§14`'s four tiers each parcel is being simulated at. */
+    tier = new Uint8Array(INITIAL_CAPACITY);
+    /** Shells actually resolved right now, which a tier may reduce below what the substance declared. */
+    shells = new Int32Array(INITIAL_CAPACITY);
+    /** Seconds owed to a parcel its cadence has been skipping, handed over when its turn comes. */
+    owed = new Float64Array(INITIAL_CAPACITY);
+    /** Consecutive ticks a parcel has been still. At `QUIET_TICKS` it sleeps. */
+    quiet = new Int32Array(INITIAL_CAPACITY);
+    /**
+     * Where each parcel's composition block starts, and the block itself.
+     *
+     * A block is `shells × the substance's own species count` kilograms — **dense over the few
+     * species that substance can hold**, not a row over all sixty-eight. Blocks are appended and
+     * never moved, which is what makes an offset stable; compaction is a budget question and belongs
+     * with the rest of them in CH-6.
+     */
+    compositionOffset = new Int32Array(INITIAL_CAPACITY);
+    composition = new Float64Array(INITIAL_CAPACITY * 8);
+    compositionUsed = 0;
+    used = 0;
+    constructor(substances, species = substances.species) {
+        this.substances = substances;
+        this.species = species;
+    }
+    /** Handles ever issued, live or not. A destroyed parcel still occupies its index. */
+    get count() {
+        return this.used;
+    }
+    spawn(spec) {
+        const { substance, mass, temperature } = spec;
+        if (!(mass > 0) || !Number.isFinite(mass)) {
+            throw new Error(`a parcel was spawned with a mass of ${mass}`);
+        }
+        const area = spec.area ?? 0;
+        if (area < 0 || !Number.isFinite(area)) {
+            throw new Error(`a parcel was spawned with a surface area of ${spec.area}`);
+        }
+        /* Resolves the substance, which refuses an index this registry never issued. */
+        const thermal = this.substances.reactionsOf(substance);
+        if (this.used === this.substance.length)
+            this.grow();
+        const parcel = this.used++;
+        this.substance[parcel] = substance;
+        this.mass[parcel] = mass;
+        const count = this.substances.conductionOf(substance).geometry.count;
+        const shellMass = mass / count;
+        /* The composition block: every shell starts as the substance says it is made. */
+        const set = this.substances.speciesSetOf(substance);
+        const block = count * set.length;
+        while (this.compositionUsed + block > this.composition.length) {
+            const grown = new Float64Array(this.composition.length * 2);
+            grown.set(this.composition);
+            this.composition = grown;
+        }
+        this.compositionOffset[parcel] = this.compositionUsed;
+        this.composition.fill(0, this.compositionUsed, this.compositionUsed + block);
+        const source = this.substances.definitionOf(substance).composition;
+        for (let i = 0; i < source.species.length; i++) {
+            const local = this.substances.localSlotOf(substance, source.species[i]);
+            const kilograms = source.fraction[i] * shellMass;
+            for (let shell = 0; shell < count; shell++) {
+                this.composition[this.compositionUsed + shell * set.length + local] = kilograms;
+            }
+        }
+        /* Enthalpy from what the shell actually holds, at the temperature asked for. Written after the
+           composition rather than before, because with CH-6's model it is a function of it. */
+        for (let shell = 0; shell < count; shell++) {
+            const base = this.compositionUsed + shell * set.length;
+            let joules = 0;
+            for (let i = 0; i < set.length; i++) {
+                const kilograms = this.composition[base + i];
+                if (kilograms === 0)
+                    continue;
+                joules +=
+                    kilograms *
+                        sensibleEnthalpy(thermal.cpA[i], thermal.cpB[i], temperature);
+            }
+            this.enthalpy[parcel * MAX_SHELLS + shell] = joules;
+        }
+        this.compositionUsed += block;
+        this.area[parcel] = area;
+        this.x[parcel] = spec.x ?? 0;
+        this.y[parcel] = spec.y ?? 0;
+        this.z[parcel] = spec.z ?? 0;
+        this.live[parcel] = 1;
+        this.flags[parcel] = 0;
+        this.flux[parcel] = 0;
+        this.fuelFlux[parcel] = 0;
+        this.release[parcel] = 0;
+        this.tier[parcel] = TIER_HERO;
+        this.shells[parcel] = count;
+        this.owed[parcel] = 0;
+        this.quiet[parcel] = 0;
+        return parcel;
+    }
+    /** m², what the environment touches. Zero means the caller has not said, and conduction refuses. */
+    areaOf(parcel) {
+        return this.area[this.check(parcel)];
+    }
+    destroy(parcel) {
+        this.live[this.check(parcel)] = 0;
+    }
+    alive(parcel) {
+        if (!Number.isInteger(parcel) || parcel < 0 || parcel >= this.used)
+            return false;
+        return this.live[parcel] === 1;
+    }
+    substanceOf(parcel) {
+        return this.substance[this.check(parcel)];
+    }
+    massOf(parcel) {
+        return this.mass[this.check(parcel)];
+    }
+    /** m³, from mass and the substance's density. Shrinks as mass leaves, which is why a log burns down. */
+    volumeOf(parcel) {
+        const at = this.check(parcel);
+        return this.mass[at] / this.substances.densityOf(this.substance[at]);
+    }
+    /** How many shells this parcel's substance divides it into. */
+    /**
+     * Shells resolved right now, which a level-of-detail tier may have reduced.
+     *
+     * Everything that walks a parcel's depth reads this rather than the substance's declared count, so
+     * a `Distant` log is one shell everywhere at once and nothing has to be told which tier it is at.
+     */
+    shellCount(parcel) {
+        return this.shells[this.check(parcel)];
+    }
+    /** What the substance asked for, which is the resolution `Hero` restores to. */
+    declaredShellsOf(parcel) {
+        return this.substances.conductionOf(this.substance[this.check(parcel)]).geometry
+            .count;
+    }
+    tierOf(parcel) {
+        return this.tier[this.check(parcel)];
+    }
+    /** Ticks between updates at this parcel's tier. `§14`'s cadence column. */
+    cadenceOf(parcel) {
+        return TIER_CADENCE[this.tier[this.check(parcel)]];
+    }
+    /** The most sub-steps a reaction solve will take at this parcel's tier. */
+    substepsOf(parcel) {
+        return TIER_SUBSTEPS[this.tier[this.check(parcel)]];
+    }
+    /**
+     * Move a parcel to a tier, **conserving mass, every element and enthalpy exactly**.
+     *
+     * `§14`: "a tier change does not lose or gain mass or energy... which is the property that makes
+     * the LOD safe to apply to a burning object mid-burn." Shells are equal-mass by construction, so a
+     * fold is a proportional redistribution — target `j` takes source shells `[j·n/m, (j+1)·n/m)`,
+     * splitting one where the ratio is not an integer — and the targets come out equal-mass too.
+     *
+     * **What it loses is the profile inside a fold**, which is the point of a tier: two shells at
+     * 400 K and 300 K become one at their mass-weighted mean, and going back up hands each of them the
+     * same mean. Resolution in depth is what a distant object gives away.
+     */
+    setTier(parcel, tier) {
+        const at = this.check(parcel);
+        const declared = this.declaredShellsOf(at);
+        const wanted = Math.min(declared, TIER_SHELLS[tier]);
+        this.tier[at] = tier;
+        const current = this.shells[at];
+        if (wanted === current)
+            return;
+        this.refold(at, current, wanted);
+        this.shells[at] = wanted;
+    }
+    /**
+     * Redistribute a parcel's `from` shells into `to`, exactly.
+     *
+     * One pass into scratch and one pass back, because a fold reads every source before it has written
+     * any target and doing it in place would read a slot it had already overwritten.
+     */
+    refold(at, from, to) {
+        const substance = this.substance[at];
+        const width = this.substances.speciesSetOf(substance).length;
+        const start = this.compositionOffset[at];
+        for (let j = 0; j < to; j++) {
+            const span = foldSpan(from, to, j);
+            let joules = 0;
+            for (let s = 0; s < width; s++)
+                foldScratch[j * MAX_SUBSTANCE_SPECIES + s] = 0;
+            for (let i = 0; i < from; i++) {
+                const share = foldShare(i, span.start, span.end);
+                if (share === 0)
+                    continue;
+                for (let s = 0; s < width; s++) {
+                    foldScratch[j * MAX_SUBSTANCE_SPECIES + s] =
+                        foldScratch[j * MAX_SUBSTANCE_SPECIES + s] +
+                            this.composition[start + i * width + s] * share;
+                }
+                joules += this.enthalpy[at * MAX_SHELLS + i] * share;
+            }
+            foldEnthalpy[j] = joules;
+        }
+        for (let j = 0; j < to; j++) {
+            for (let s = 0; s < width; s++) {
+                this.composition[start + j * width + s] = foldScratch[j * MAX_SUBSTANCE_SPECIES + s];
+            }
+            this.enthalpy[at * MAX_SHELLS + j] = foldEnthalpy[j];
+        }
+        /* Beyond the new count nothing is read, and leaving stale values there would show up the day
+           somebody added a loop over `MAX_SHELLS` instead of over `shellCount`. */
+        for (let j = to; j < from; j++) {
+            for (let s = 0; s < width; s++)
+                this.composition[start + j * width + s] = 0;
+            this.enthalpy[at * MAX_SHELLS + j] = 0;
+        }
+    }
+    /** Total joules held across every shell, not joules per kilogram. */
+    enthalpyOf(parcel) {
+        const at = this.check(parcel);
+        const count = this.shellCount(at);
+        let total = 0;
+        for (let i = 0; i < count; i++)
+            total += this.enthalpy[at * MAX_SHELLS + i];
+        return total;
+    }
+    shellEnthalpyOf(parcel, shell) {
+        return this.enthalpy[this.check(parcel) * MAX_SHELLS + this.checkShell(parcel, shell)];
+    }
+    /**
+     * The temperature of one shell, K. Shell 0 is the surface and the last is the core.
+     *
+     * **`surfaceTemperatureOf` is what decides ignition and `coreTemperatureOf` is what decides
+     * doneness**, and the gap between them is the whole reason shells exist.
+     */
+    shellTemperatureOf(parcel, shell) {
+        const at = this.check(parcel);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        const thermal = this.substances.reactionsOf(substance);
+        const width = this.substances.speciesSetOf(substance).length;
+        const base = this.compositionOffset[at] + index * width;
+        let A = 0;
+        let B = 0;
+        for (let i = 0; i < width; i++) {
+            const kilograms = this.composition[base + i];
+            if (kilograms === 0)
+                continue;
+            A += kilograms * thermal.cpA[i];
+            B += kilograms * thermal.cpB[i];
+        }
+        return temperatureFromCapacity(A, B, this.enthalpy[at * MAX_SHELLS + index]);
+    }
+    surfaceTemperatureOf(parcel) {
+        return this.shellTemperatureOf(parcel, 0);
+    }
+    coreTemperatureOf(parcel) {
+        return this.shellTemperatureOf(parcel, this.shellCount(parcel) - 1);
+    }
+    positionX(parcel) {
+        return this.x[this.check(parcel)];
+    }
+    positionY(parcel) {
+        return this.y[this.check(parcel)];
+    }
+    positionZ(parcel) {
+        return this.z[this.check(parcel)];
+    }
+    move(parcel, x, y, z) {
+        const at = this.check(parcel);
+        this.x[at] = x;
+        this.y[at] = y;
+        this.z[at] = z;
+    }
+    /**
+     * The temperature this parcel would have if it were stirred, K.
+     *
+     * A read rather than a stored field, and that is the design. Nothing writes a temperature except
+     * `setTemperature`, which writes the enthalpy that produces one — so a parcel on a plateau simply
+     * does not move, and no code anywhere had to know a plateau exists.
+     *
+     * **The temperature of the total enthalpy**, not the mean of the shell temperatures. The two
+     * differ wherever the curve bends, and only this one has the property that matters: heat in,
+     * temperature out, with nothing lost between them.
+     */
+    temperatureOf(parcel) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const thermal = this.substances.reactionsOf(substance);
+        const width = this.substances.speciesSetOf(substance).length;
+        const count = this.shellCount(at);
+        const start = this.compositionOffset[at];
+        let A = 0;
+        let B = 0;
+        for (let shell = 0; shell < count; shell++) {
+            const base = start + shell * width;
+            for (let i = 0; i < width; i++) {
+                const kilograms = this.composition[base + i];
+                if (kilograms === 0)
+                    continue;
+                A += kilograms * thermal.cpA[i];
+                B += kilograms * thermal.cpB[i];
+            }
+        }
+        return temperatureFromCapacity(A, B, this.enthalpyOf(at));
+    }
+    /** Joules in, spread evenly through the depth. Negative cools. A microwave, or a stirred pot. */
+    addHeat(parcel, joules) {
+        const at = this.check(parcel);
+        this.wake(at);
+        const count = this.shellCount(at);
+        const share = joules / count;
+        for (let i = 0; i < count; i++) {
+            this.enthalpy[at * MAX_SHELLS + i] = this.enthalpy[at * MAX_SHELLS + i] + share;
+        }
+    }
+    /**
+     * Joules into shell 0 alone, which is what a flux from outside actually does.
+     *
+     * Every radiative, convective and contact term in CH-5 lands here. The difference between this
+     * and `addHeat` is the difference between a log in front of a fire and a log in an oven.
+     */
+    addSurfaceHeat(parcel, joules) {
+        const at = this.check(parcel);
+        this.wake(at);
+        this.enthalpy[at * MAX_SHELLS] = this.enthalpy[at * MAX_SHELLS] + joules;
+    }
+    /**
+     * Conduct heat inward one step of `dt` seconds.
+     *
+     * Conserves this parcel's total enthalpy exactly — the arithmetic is in `conduction.ts` and so is
+     * the reason.
+     */
+    conduct(parcel, dt) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        /* The geometry for the shells this parcel is *currently* resolved to, which its tier decides. */
+        const model = this.substances.conductionAt(substance, this.shells[at]);
+        if (model.geometry.count < 2)
+            return;
+        if (model.conductivity === null) {
+            throw new Error(`substance "${this.substances.idOf(substance)}" has no conductivity, so it cannot conduct`);
+        }
+        const area = this.area[at];
+        if (!(area > 0)) {
+            throw new Error(`parcel ${parcel} has no surface area, and a characteristic depth is volume over area`);
+        }
+        const volume = this.mass[at] / this.substances.densityOf(substance);
+        const depth = (model.geometry.depthFactor * volume) / area;
+        conductShells(this.enthalpy, at * MAX_SHELLS, model, this.substances.reactionsOf(substance), this.composition, this.compositionOffset[at], this.mass[at] / model.geometry.count, area, depth, dt);
+    }
+    /**
+     * Force a temperature by writing the enthalpy that produces it.
+     *
+     * For authoring and for tests. **Not for a tick**: it discards whatever enthalpy the parcel held,
+     * so a boiling parcel set to its own boiling point loses however much of the plateau it had
+     * crossed, and the energy budget does not close across the call.
+     */
+    setTemperature(parcel, temperature) {
+        const at = this.check(parcel);
+        const count = this.shellCount(at);
+        for (let i = 0; i < count; i++)
+            this.setShellTemperature(at, i, temperature);
+    }
+    /** Force one shell's temperature. Authoring and tests only, for the reason above. */
+    setShellTemperature(parcel, shell, temperature) {
+        const at = this.check(parcel);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        const thermal = this.substances.reactionsOf(substance);
+        const width = this.substances.speciesSetOf(substance).length;
+        const base = this.compositionOffset[at] + index * width;
+        let joules = 0;
+        for (let i = 0; i < width; i++) {
+            const kilograms = this.composition[base + i];
+            if (kilograms === 0)
+                continue;
+            joules +=
+                kilograms *
+                    sensibleEnthalpy(thermal.cpA[i], thermal.cpB[i], temperature);
+        }
+        this.enthalpy[at * MAX_SHELLS + index] = joules;
+    }
+    /** Kilograms of one species in one shell. Zero where the substance cannot hold it at all. */
+    speciesMassOf(parcel, shell, species) {
+        const at = this.check(parcel);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        const local = this.substances.localSlotOf(substance, species);
+        if (local < 0)
+            return 0;
+        const width = this.substances.speciesSetOf(substance).length;
+        return this.composition[this.compositionOffset[at] + index * width + local];
+    }
+    /** The same, summed over every shell. */
+    parcelSpeciesMass(parcel, species) {
+        const at = this.check(parcel);
+        const count = this.shellCount(at);
+        let total = 0;
+        for (let shell = 0; shell < count; shell++)
+            total += this.speciesMassOf(at, shell, species);
+        return total;
+    }
+    /** Kilograms in one shell, summed over its species. Invariant under reaction. */
+    shellMassOf(parcel, shell) {
+        const at = this.check(parcel);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        const width = this.substances.speciesSetOf(substance).length;
+        const start = this.compositionOffset[at] + index * width;
+        let total = 0;
+        for (let i = 0; i < width; i++)
+            total += this.composition[start + i];
+        return total;
+    }
+    /** Moles of each element this parcel holds. Writes into `out`, allocates nothing. */
+    elementTotalsOf(parcel, out) {
+        if (out.length !== ELEMENT_COUNT) {
+            throw new Error(`a totals vector is ${ELEMENT_COUNT} wide, not ${out.length}`);
+        }
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const set = this.substances.speciesSetOf(substance);
+        const model = this.substances.reactionsOf(substance);
+        const count = this.shellCount(at);
+        const start = this.compositionOffset[at];
+        out.fill(0);
+        for (let shell = 0; shell < count; shell++) {
+            for (let i = 0; i < set.length; i++) {
+                const kilograms = this.composition[start + shell * set.length + i];
+                if (kilograms === 0)
+                    continue;
+                this.species.elements.addScaledRow(set[i], kilograms / model.molarMass[i], out);
+            }
+        }
+    }
+    /**
+     * Energy locked in this parcel's chemical bonds, J.
+     *
+     * Neither this nor the thermal enthalpy is conserved on its own — a reaction moves energy between
+     * them. **Their sum is**, exactly, because the same number is added to one and taken from the
+     * other in `reactShell`.
+     */
+    chemicalEnergyOf(parcel) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const set = this.substances.speciesSetOf(substance);
+        const model = this.substances.reactionsOf(substance);
+        const count = this.shellCount(at);
+        const start = this.compositionOffset[at];
+        let total = 0;
+        for (let shell = 0; shell < count; shell++) {
+            for (let i = 0; i < set.length; i++) {
+                const kilograms = this.composition[start + shell * set.length + i];
+                if (kilograms === 0)
+                    continue;
+                total +=
+                    (kilograms / model.molarMass[i]) *
+                        this.species.formationEnthalpyOf(set[i]);
+            }
+        }
+        return total;
+    }
+    /** Run this parcel's reactions in every shell for `dt` seconds. */
+    react(parcel, dt, transportFactor = 1) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const model = this.substances.reactionsOf(substance);
+        if (model.count === 0) {
+            this.release[at] = 0;
+            return;
+        }
+        const count = this.shellCount(at);
+        /* Bracketing the reaction step is the only place heat release can honestly be read: outside it,
+           conduction and a radiative source have moved the same joules in the same tick. */
+        const before = this.thermalEnthalpy(at, count);
+        const width = this.substances.speciesSetOf(substance).length;
+        const start = this.compositionOffset[at];
+        const shellMass = this.mass[at] / count;
+        for (let shell = 0; shell < count; shell++) {
+            reactShell(this.composition, start + shell * width, this.enthalpy, at * MAX_SHELLS + shell, model, shellMass, dt, transportFactor);
+        }
+        this.release[at] = dt > 0 ? (this.thermalEnthalpy(at, count) - before) / dt : 0;
+    }
+    /** Joules of sensible heat across a parcel's shells. One pass over at most sixteen doubles. */
+    thermalEnthalpy(at, count) {
+        let total = 0;
+        for (let shell = 0; shell < count; shell++) {
+            total += this.enthalpy[at * MAX_SHELLS + shell];
+        }
+        return total;
+    }
+    /**
+     * Whether this parcel is being skipped entirely.
+     *
+     * `§14`'s thermal quiescence, and the vocabulary is deliberately Track B's. A cold stone floor is a
+     * thousand of these and costs a bounded scan.
+     */
+    sleeping(parcel) {
+        return (this.flags[this.check(parcel)] & FLAG_SLEEPING) !== 0;
+    }
+    /**
+     * Wake it, and reset the count that would put it back.
+     *
+     * **Called by everything that could change what a parcel is**: heat arriving, water poured on,
+     * mass added, a contact, or a source coming within range. Cheap enough — a flag and an integer —
+     * that a caller never has to decide whether it is worth it.
+     */
+    wake(parcel) {
+        const at = this.check(parcel);
+        this.flags[at] = this.flags[at] & ~FLAG_SLEEPING;
+        this.quiet[at] = 0;
+    }
+    /**
+     * Decide whether this parcel is still enough to sleep, and put it to sleep if it has been for long
+     * enough. Returns whether it is now asleep.
+     *
+     * **A burning or smouldering parcel never sleeps, whatever its numbers say.** A steady flame is a
+     * *steady* parcel by every measure here, and sleeping one would put out a fire by optimising it.
+     */
+    settle(parcel) {
+        const at = this.check(parcel);
+        if ((this.flags[at] & (FLAG_BURNING | FLAG_SMOULDERING)) !== 0) {
+            this.quiet[at] = 0;
+            return false;
+        }
+        const still = this.flux[at] < QUIET_FLUX &&
+            Math.abs(this.release[at]) < QUIET_RELEASE;
+        if (!still) {
+            this.quiet[at] = 0;
+            this.flags[at] = this.flags[at] & ~FLAG_SLEEPING;
+            return false;
+        }
+        const count = this.quiet[at] + 1;
+        this.quiet[at] = count;
+        if (count < QUIET_TICKS)
+            return false;
+        this.flags[at] = this.flags[at] | FLAG_SLEEPING;
+        return true;
+    }
+    /**
+     * Seconds this parcel is owed by its cadence, and whether its turn has come.
+     *
+     * A `Far` parcel is stepped every fourth tick with four ticks of `dt`, so the same seconds are
+     * integrated either way — which is what makes a cadence conserving for free rather than by care.
+     */
+    accrue(parcel, dt) {
+        const at = this.check(parcel);
+        const owed = this.owed[at] + dt;
+        const cadence = TIER_CADENCE[this.tier[at]];
+        if (cadence <= 1 || owed >= dt * cadence * 0.999999) {
+            this.owed[at] = 0;
+            return owed;
+        }
+        this.owed[at] = owed;
+        return 0;
+    }
+    /** Whether a flame stands over this parcel. */
+    burning(parcel) {
+        return (this.flags[this.check(parcel)] & FLAG_BURNING) !== 0;
+    }
+    /** Whether its char is glowing, which needs no flame and far less oxygen. */
+    smouldering(parcel) {
+        return (this.flags[this.check(parcel)] & FLAG_SMOULDERING) !== 0;
+    }
+    /** Whether a pilot is present this tick. */
+    piloted(parcel) {
+        return (this.flags[this.check(parcel)] & FLAG_PILOT) !== 0;
+    }
+    /**
+     * Supply a pilot for one tick. **This does not start a fire**, and `§11` is why.
+     *
+     * Ignition is five conditions, and a pilot is one of them. Holding a match to wet wood does
+     * exactly nothing here, which is correct and is the API telling the truth about what a match is.
+     */
+    ignite(parcel) {
+        this.wake(parcel);
+        this.flags[this.check(parcel)] = this.flags[parcel] | FLAG_PILOT;
+    }
+    /** Put the flame out. Embers survive, which is the point — see `§12`. */
+    douse(parcel) {
+        this.flags[this.check(parcel)] = this.flags[parcel] & ~FLAG_BURNING;
+    }
+    setBurning(parcel, burning) {
+        const at = this.check(parcel);
+        this.flags[at] = burning
+            ? this.flags[at] | FLAG_BURNING
+            : this.flags[at] & ~FLAG_BURNING;
+    }
+    setSmouldering(parcel, smouldering) {
+        const at = this.check(parcel);
+        this.flags[at] = smouldering
+            ? this.flags[at] | FLAG_SMOULDERING
+            : this.flags[at] & ~FLAG_SMOULDERING;
+    }
+    clearPilot(parcel) {
+        this.flags[this.check(parcel)] = this.flags[parcel] & ~FLAG_PILOT;
+    }
+    /** kg/(m²·s) of gas leaving the surface, all of it. */
+    massFluxOf(parcel) {
+        return this.flux[this.check(parcel)];
+    }
+    /**
+     * And of the part of it that can burn — which is the criterion ignition turns on.
+     *
+     * The two differ by exactly what a wet log gives off. Steam leaving a surface counts toward
+     * diluting the mixture above it and not toward feeding it, which is why 60% moisture stops a log
+     * catching in front of a fire that lights a seasoned one in eighty seconds.
+     */
+    fuelFluxOf(parcel) {
+        return this.fuelFlux[this.check(parcel)];
+    }
+    setMassFlux(parcel, total, fuel) {
+        const at = this.check(parcel);
+        this.flux[at] = total > 0 ? total : 0;
+        this.fuelFlux[at] = fuel > 0 ? fuel : 0;
+    }
+    /**
+     * Watts the reactions released last step: positive exothermic, negative endothermic.
+     *
+     * **A fire's size is its heat release rate**, which is what every figure in the design is quoted
+     * against and is not the temperature. A pyrolysing surface reads *negative* here while it is
+     * gasifying, which is right and is why a flame has to keep feeding heat back to sustain one.
+     */
+    heatReleaseOf(parcel) {
+        return this.release[this.check(parcel)];
+    }
+    /**
+     * Kilograms of water per kilogram of dry matter — **the dry basis, which is how it is quoted**.
+     *
+     * "12% moisture content" means twelve kilograms of water per hundred of dry wood, and
+     * `wetComposition` folded that into a wet-basis 0.107 to store it. Undoing the same conversion
+     * here is what makes a script comparing against the 0.25 that decides whether a log is worth
+     * burning read the quantity the author wrote.
+     *
+     * Ice counts as water. A frozen log is not a dry one.
+     */
+    moistureOf(parcel) {
+        const at = this.check(parcel);
+        const liquid = this.species.indexOf('H2O(l)');
+        const solid = this.species.indexOf('H2O(s)');
+        let water = 0;
+        if (liquid >= 0)
+            water += this.parcelSpeciesMass(at, liquid);
+        if (solid >= 0)
+            water += this.parcelSpeciesMass(at, solid);
+        const dry = this.mass[at] - water;
+        return dry > 0 ? water / dry : 0;
+    }
+    /**
+     * `PHASE_SOLID`, `PHASE_LIQUID`, `PHASE_GAS`, or `PHASE_MIXED` where no one of them dominates.
+     *
+     * Mixed is a real answer rather than a failure to decide: wet wood is wood and water at once, and
+     * calling it either would be a lie a consumer would then draw.
+     */
+    parcelPhaseOf(parcel) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const set = this.substances.speciesSetOf(substance);
+        const count = this.shellCount(at);
+        const start = this.compositionOffset[at];
+        let total = 0;
+        let solid = 0;
+        let liquid = 0;
+        let gas = 0;
+        for (let shell = 0; shell < count; shell++) {
+            for (let i = 0; i < set.length; i++) {
+                const kilograms = this.composition[start + shell * set.length + i];
+                if (kilograms === 0)
+                    continue;
+                total += kilograms;
+                const phase = this.species.phaseOf(set[i]);
+                if (phase === PHASE_SOLID)
+                    solid += kilograms;
+                else if (phase === PHASE_LIQUID)
+                    liquid += kilograms;
+                else
+                    gas += kilograms;
+            }
+        }
+        if (!(total > 0))
+            return PHASE_MIXED;
+        const dominant = PHASE_DOMINANT * total;
+        if (solid >= dominant)
+            return PHASE_SOLID;
+        if (liquid >= dominant)
+            return PHASE_LIQUID;
+        if (gas >= dominant)
+            return PHASE_GAS;
+        return PHASE_MIXED;
+    }
+    /**
+     * Kilograms of **free** water on the surface, per square metre of it.
+     *
+     * **Free, meaning beyond what the material holds as its own moisture**, and that distinction is
+     * the whole reading. A seasoned oak log carries 12% water on a dry basis and is not glossy; a log
+     * somebody threw a bucket over is. Reporting the shell's total water would make the two identical
+     * and every piece of wood in a scene look rained on.
+     *
+     * **Derived rather than a column**, because `wet` puts real water in the surface shell rather than
+     * setting a flag — so `§17`'s wet-film roughness reads a quantity the boiling reaction is
+     * simultaneously consuming, which is what makes drying visible.
+     */
+    wetnessOf(parcel) {
+        const at = this.check(parcel);
+        const area = this.area[at];
+        if (!(area > 0))
+            return 0;
+        const water = this.species.indexOf('H2O(l)');
+        if (water < 0)
+            return 0;
+        /*
+         * Measured **on a dry basis against the shell's own dry matter**, which is the one formulation
+         * that is stable under pouring water on it. Against a fraction of the shell's *total* mass, the
+         * baseline would grow with every drop added and a bucket would read as a third of itself.
+         */
+        const substance = this.substance[at];
+        const composition = this.substances.definitionOf(substance).composition;
+        let wetBasis = 0;
+        for (let i = 0; i < composition.species.length; i++) {
+            if (composition.species[i] === water)
+                wetBasis = composition.fraction[i];
+        }
+        if (!(wetBasis < 1))
+            return 0;
+        const held = this.speciesMassOf(at, 0, water);
+        const dry = this.shellMassOf(at, 0) - held;
+        const authored = dry * (wetBasis / (1 - wetBasis));
+        const free = held - authored;
+        return free > 0 ? free / area : 0;
+    }
+    /**
+     * Pour water on it: liquid water into the surface shell, where the boiling reaction will find it.
+     *
+     * **Not a flag, and that is the whole point.** The heat sink `§12` describes is the same
+     * 2.44 MJ/kg every other drop of water in this model carries, so a doused fire goes out for the
+     * reason a real one does and a light sprinkling on a hot ember does not.
+     *
+     * Refused, naming the substance, where that substance cannot hold water at all — which means it
+     * declares no reaction that touches it. Silently doing nothing would make "I poured a bucket on
+     * it" and "this material has no water in its model" indistinguishable.
+     */
+    wet(parcel, kilograms) {
+        const at = this.check(parcel);
+        this.wake(at);
+        if (!(kilograms > 0))
+            return;
+        const water = this.species.indexOf('H2O(l)');
+        const substance = this.substance[at];
+        if (water < 0 || this.substances.localSlotOf(substance, water) < 0) {
+            throw new Error(`parcel ${parcel} is ${this.substances.idOf(substance)}, which holds no liquid water — ` +
+                'declare a reaction that touches `H2O(l)`, such as `boil-water`, to make it wettable');
+        }
+        this.addSpeciesMass(at, 0, water, kilograms);
+        this.mass[at] = this.mass[at] + kilograms;
+    }
+    /** Take surface water away: a cloth, a hot dry pan, or wind. Never below what is there. */
+    dry(parcel, kilograms) {
+        const at = this.check(parcel);
+        if (!(kilograms > 0))
+            return;
+        const water = this.species.indexOf('H2O(l)');
+        if (water < 0 || this.substances.localSlotOf(this.substance[at], water) < 0)
+            return;
+        const held = this.speciesMassOf(at, 0, water);
+        const taken = kilograms < held ? kilograms : held;
+        this.addSpeciesMass(at, 0, water, -taken);
+        this.mass[at] = this.mass[at] - taken;
+    }
+    /**
+     * Metres of char measured inward from the surface.
+     *
+     * The shells that are mostly carbon, summed by their own thickness. A shell counts once it is past
+     * half char, which is a threshold on a continuum and is said out loud: a finer answer needs a char
+     * *front* within a shell, which is a sub-shell quantity this model does not carry.
+     */
+    charDepthOf(parcel) {
+        const at = this.check(parcel);
+        const char = this.species.indexOf('C(char)');
+        if (char < 0)
+            return 0;
+        const count = this.shellCount(at);
+        let depth = 0;
+        for (let shell = 0; shell < count; shell++) {
+            const mass = this.shellMassOf(at, shell);
+            if (!(mass > 0))
+                continue;
+            if (this.speciesMassOf(at, shell, char) / mass < CHAR_SHELL_FRACTION)
+                break;
+            depth += this.shellDepthOf(at, shell);
+        }
+        return depth;
+    }
+    /**
+     * How much of this parcel is still load-bearing, 1 down to 0.
+     *
+     * **`§18` refuses structural failure in writing and this is the refusal reporting.** A beam whose
+     * char depth has eaten a fraction of its thickness has lost that fraction of its strength, and
+     * what happens next — a joint releasing, a body splitting, a building coming down — belongs to
+     * whoever owns the solver. This package writes the scalar, emits an event at a threshold, and
+     * breaks nothing.
+     */
+    structuralIntegrityOf(parcel) {
+        const at = this.check(parcel);
+        const count = this.shellCount(at);
+        let thickness = 0;
+        for (let shell = 0; shell < count; shell++)
+            thickness += this.shellDepthOf(at, shell);
+        if (!(thickness > 0))
+            return 1;
+        const left = 1 - this.charDepthOf(at) / thickness;
+        return left > 0 ? (left < 1 ? left : 1) : 0;
+    }
+    /**
+     * Pour `from` into `into`; `from` is consumed. Mass, elements and enthalpy all conserved exactly.
+     *
+     * **Both must be the same substance, and two that are not are refused naming both.** Two
+     * substances are two species sets and two shell counts, so mixing them would silently discard
+     * whichever set was narrower — and a stew is not a substance change. What a consumer combining two
+     * genuinely different materials wants is a third substance that is the mixture, authored as one.
+     */
+    mix(from, into) {
+        const a = this.check(from);
+        const b = this.check(into);
+        if (a === b)
+            return;
+        const substance = this.substance[a];
+        if (substance !== this.substance[b]) {
+            throw new Error(`cannot mix ${this.substances.idOf(substance)} into ` +
+                `${this.substances.idOf(this.substance[b])}: two substances are two species ` +
+                'sets, and a mixture of them is a third substance rather than either');
+        }
+        const set = this.substances.speciesSetOf(substance);
+        const countA = this.shellCount(a);
+        const countB = this.shellCount(b);
+        const startA = this.compositionOffset[a];
+        const startB = this.compositionOffset[b];
+        /* Spread over the receiver's shells in proportion to what each already holds, so a hot core
+           stays hotter than a cold surface rather than being averaged flat. */
+        const massB = this.mass[b];
+        for (let shell = 0; shell < countB; shell++) {
+            const share = massB > 0 ? this.shellMassOf(b, shell) / massB : 1 / countB;
+            for (let i = 0; i < set.length; i++) {
+                let incoming = 0;
+                for (let s = 0; s < countA; s++)
+                    incoming += this.composition[startA + s * set.length + i];
+                this.composition[startB + shell * set.length + i] =
+                    this.composition[startB + shell * set.length + i] + incoming * share;
+            }
+            let joules = 0;
+            for (let s = 0; s < countA; s++)
+                joules += this.enthalpy[a * MAX_SHELLS + s];
+            this.enthalpy[b * MAX_SHELLS + shell] =
+                this.enthalpy[b * MAX_SHELLS + shell] + joules * share;
+        }
+        this.mass[b] = massB + this.mass[a];
+        this.destroy(a);
+    }
+    /**
+     * Joules into one named shell.
+     *
+     * The difference between this and `addSurfaceHeat` is a microwave and an oven: one deposits where
+     * the field penetrates to, the other at the surface. Nothing here decides which is physical.
+     */
+    addShellHeat(parcel, shell, joules) {
+        const at = this.check(parcel);
+        this.wake(at);
+        const index = this.checkShell(at, shell);
+        this.enthalpy[at * MAX_SHELLS + index] =
+            this.enthalpy[at * MAX_SHELLS + index] + joules;
+    }
+    /**
+     * What fraction of its original volume is left, as mass leaves it.
+     *
+     * **The number a shrinking log is drawn from.** A parcel's volume is its mass over its substance's
+     * density, and the density does not change — so this is simply what share of the mass is still
+     * here, which falls as volatiles leave and rises for nothing.
+     */
+    volumeShareOf(parcel) {
+        const at = this.check(parcel);
+        let held = 0;
+        const count = this.shellCount(at);
+        for (let shell = 0; shell < count; shell++)
+            held += this.shellMassOf(at, shell);
+        const original = this.mass[at];
+        return original > 0 ? held / original : 0;
+    }
+    /**
+     * Joules per kelvin of the surface shell, from what it is made of right now.
+     *
+     * **What every explicit surface term has to be bounded against.** A flux times an area times a
+     * step is joules, and joules into a small enough shell is an arbitrarily large temperature change
+     * — so a term that does not know this number cannot tell the difference between heating something
+     * and destroying it. `ChemistryWorld` uses it to stop a radiative or convective step carrying a
+     * surface past the thing driving it.
+     */
+    surfaceHeatCapacityOf(parcel) {
+        const at = this.check(parcel);
+        const substance = this.substance[at];
+        const set = this.substances.speciesSetOf(substance);
+        const model = this.substances.reactionsOf(substance);
+        const start = this.compositionOffset[at];
+        const temperature = this.shellTemperatureOf(at, 0);
+        let capacity = 0;
+        for (let i = 0; i < set.length; i++) {
+            const kilograms = this.composition[start + i];
+            if (kilograms === 0)
+                continue;
+            capacity +=
+                kilograms * (model.cpA[i] + model.cpB[i] * (temperature - 273.15));
+        }
+        return capacity;
+    }
+    /** What this parcel's substance looks like, or `null` where nobody said. */
+    appearanceOf(parcel) {
+        return this.substances.appearanceOf(this.substance[this.check(parcel)]);
+    }
+    /** Share of this parcel's mass that is char, 0..1. */
+    charFractionOf(parcel) {
+        const at = this.check(parcel);
+        const char = this.species.indexOf('C(char)');
+        if (char < 0)
+            return 0;
+        const mass = this.mass[at];
+        return mass > 0 ? this.parcelSpeciesMass(at, char) / mass : 0;
+    }
+    /** Add (or with a negative value, remove) mass of one species in one shell. */
+    addSpeciesMass(parcel, shell, species, kilograms) {
+        const at = this.check(parcel);
+        this.wake(at);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        const local = this.substances.localSlotOf(substance, species);
+        if (local < 0) {
+            throw new Error(`parcel ${parcel} is ${this.substances.idOf(substance)}, which cannot hold ` +
+                `"${this.species.idOf(species)}"`);
+        }
+        const width = this.substances.speciesSetOf(substance).length;
+        const slot = this.compositionOffset[at] + index * width + local;
+        const next = this.composition[slot] + kilograms;
+        this.composition[slot] = next > 0 ? next : 0;
+    }
+    /** How many substances this store's registry holds. `fingerprintChemistry` covers all of them. */
+    get substanceCount() {
+        return this.substances.count;
+    }
+    /**
+     * A number standing for what a registered substance *is*, for the fingerprint.
+     *
+     * Its density, porosity, emissivity, shell count and the species it can hold — enough that two
+     * libraries differing anywhere disagree here, and cheap enough to compute once a tick. `§15` asks
+     * for the registry to be covered because two worlds with different substances are different
+     * worlds, and a replay crossing them should say so rather than diverge later.
+     */
+    substanceDigestOf(substance) {
+        const set = this.substances.speciesSetOf(substance);
+        let digest = this.substances.densityOf(substance) +
+            this.substances.porosityOf(substance) * 7 +
+            this.substances.emissivityOf(substance) * 13 +
+            set.length * 31;
+        for (let i = 0; i < set.length; i++)
+            digest += set[i] * (i + 1);
+        return digest;
+    }
+    /** Global species indices this parcel's substance can hold. */
+    speciesSetOf(substance) {
+        return this.substances.speciesSetOf(substance);
+    }
+    idOfSpecies(species) {
+        return this.species.idOf(species);
+    }
+    phaseOf(species) {
+        return this.species.phaseOf(species);
+    }
+    emissivityOf(parcel) {
+        return this.substances.emissivityOf(this.substance[this.check(parcel)]);
+    }
+    /** When this parcel's substance catches, or `null` where nobody said it does. */
+    ignitionOf(substance) {
+        return this.substances.ignitionOf(substance);
+    }
+    porosityOf(parcel) {
+        return this.substances.porosityOf(this.substance[this.check(parcel)]);
+    }
+    /** W/(m·K) at a temperature, or zero where the substance never said. */
+    conductivityOf(parcel, temperature) {
+        const model = this.substances.conductionOf(this.substance[this.check(parcel)]);
+        const k = model.conductivity;
+        if (k === null)
+            return 0;
+        const value = k.k0 + k.k1 * (temperature - 298.15);
+        return value > 0 ? value : 0;
+    }
+    /** Metres from the outside of shell `shell` to the inside of it. */
+    shellDepthOf(parcel, shell) {
+        const at = this.check(parcel);
+        const index = this.checkShell(at, shell);
+        const substance = this.substance[at];
+        /* At the shells this parcel is currently resolved to: a `Distant` log is one thick shell, and a
+           depth read against the declared four would be a quarter of the real thing. */
+        const model = this.substances.conductionAt(substance, this.shells[at]);
+        const area = this.area[at];
+        if (!(area > 0))
+            return 0;
+        const volume = this.mass[at] / this.substances.densityOf(substance);
+        const depth = (model.geometry.depthFactor * volume) / area;
+        return depth * model.geometry.thicknessFraction[index];
+    }
+    checkShell(parcel, shell) {
+        const count = this.shellCount(parcel);
+        if (!Number.isInteger(shell) || shell < 0 || shell >= count) {
+            throw new Error(`shell ${shell} is outside a parcel of ${count}`);
+        }
+        return shell;
+    }
+    grow() {
+        const size = this.substance.length * 2;
+        const substance = new Int32Array(size);
+        substance.set(this.substance);
+        this.substance = substance;
+        /* Explicitly `Float64Array<ArrayBuffer>` rather than inferred: TypeScript 7 parameterises a
+           typed array by its buffer, and an unannotated parameter widens to `ArrayBufferLike` — which
+           includes `SharedArrayBuffer` and so will not assign back to the fields. */
+        const grow64 = (from) => {
+            const to = new Float64Array(size);
+            to.set(from);
+            return to;
+        };
+        this.mass = grow64(this.mass);
+        this.area = grow64(this.area);
+        const enthalpy = new Float64Array(size * MAX_SHELLS);
+        enthalpy.set(this.enthalpy);
+        this.enthalpy = enthalpy;
+        this.x = grow64(this.x);
+        this.y = grow64(this.y);
+        this.z = grow64(this.z);
+        const live = new Uint8Array(size);
+        live.set(this.live);
+        this.live = live;
+        const flags = new Uint8Array(size);
+        flags.set(this.flags);
+        this.flags = flags;
+        this.flux = grow64(this.flux);
+        this.fuelFlux = grow64(this.fuelFlux);
+        this.release = grow64(this.release);
+        this.owed = grow64(this.owed);
+        const tier = new Uint8Array(size);
+        tier.set(this.tier);
+        this.tier = tier;
+        const shells = new Int32Array(size);
+        shells.set(this.shells);
+        this.shells = shells;
+        const quiet = new Int32Array(size);
+        quiet.set(this.quiet);
+        this.quiet = quiet;
+        const offsets = new Int32Array(size);
+        offsets.set(this.compositionOffset);
+        this.compositionOffset = offsets;
+    }
+    check(parcel) {
+        if (!Number.isInteger(parcel) || parcel < 0 || parcel >= this.used) {
+            throw new Error(`parcel ${parcel} is outside a store of ${this.used}`);
+        }
+        if (this.live[parcel] !== 1) {
+            throw new Error(`parcel ${parcel} was destroyed`);
+        }
+        return parcel;
+    }
+}