@driftengine/chemistry 3.61.0

package/src/substance/registry.ts

@@ -0,0 +1,223 @@
+/**
+ * The substances a world knows about, and the enthalpy curve each one resolves through.
+ *
+ * A curve is expensive to build and constant for the life of a substance, so it is built once here
+ * rather than per parcel. Two hundred oak logs share one curve, which is what makes the whole
+ * approach affordable: the per-parcel cost of a temperature is a binary search over 256 knots and
+ * nothing else.
+ *
+ * A substance is an `i32` index after registration, the convention CH-0 established for a species
+ * and `drift/physics` established for a body.
+ */
+import { type ConductionModel } from '../parcel/conduction.ts';
+import { SHAPE_CYLINDER, shellGeometry } from '../parcel/shells.ts';
+import type { SpeciesRegistry } from '../species/registry.ts';
+import type { AppearanceModel, SubstanceThermal } from './substance.ts';
+import type { IgnitionModel } from '../ignition/criteria.ts';
+import type { ReactionRegistry } from '../reaction/registry.ts';
+import { MAX_SUBSTANCE_SPECIES, type SubstanceReactions } from '../reaction/solver.ts';
+import { localiseReactions } from '../reaction/localise.ts';
+
+export class SubstanceRegistry {
+  private readonly ids: string[] = [];
+  private readonly byId = new Map<string, number>();
+  private readonly definitions: SubstanceThermal[] = [];
+  private readonly conduction: ConductionModel[] = [];
+  /**
+   * One conduction model per shell count a tier can reduce this substance to, indexed by that count.
+   *
+   * **Built at registration, because `shellGeometry` calls `Math.cbrt`** and `§15` keeps that off the
+   * simulation path entirely — its result is not pinned down by ECMAScript. A level-of-detail tier
+   * that computed geometry when it changed would have put it back there. Four shapes and at most
+   * sixteen counts is nothing to precompute and the alternative is a determinism hole.
+   */
+  private readonly byShellCount: (ConductionModel | null)[][] = [];
+  private readonly reactionModels: SubstanceReactions[] = [];
+  /** Global species indices this substance's parcels track, ascending. */
+  private readonly speciesSets: Int32Array[] = [];
+  /** Global species index to local slot, or -1. One row per substance. */
+  private readonly localSlots: Int32Array[] = [];
+  private readonly densities: number[] = [];
+  private readonly porosities: number[] = [];
+  private readonly emissivities: number[] = [];
+  private readonly ignitions: (IgnitionModel | null)[] = [];
+  private readonly appearances: (AppearanceModel | null)[] = [];
+
+  constructor(
+    readonly species: SpeciesRegistry,
+    private readonly reactions?: ReactionRegistry,
+  ) {}
+
+  get count(): number {
+    return this.ids.length;
+  }
+
+  define(substance: SubstanceThermal): number {
+    if (this.byId.has(substance.id)) {
+      throw new Error(`substance "${substance.id}" is already registered`);
+    }
+    if (!(substance.density > 0)) {
+      throw new Error(`substance "${substance.id}" has a density of ${substance.density}`);
+    }
+    /* The shell geometry is a pure function of a shape and a count, so it is resolved here once and
+       multiplied by a parcel's own depth at use — which keeps `Math.cbrt`, whose result ECMAScript
+       does not pin down, off the simulation path entirely. */
+    const geometry = shellGeometry(substance.shape ?? SHAPE_CYLINDER, substance.shells ?? 4);
+
+    const { set, local, model } = this.buildReactions(substance);
+
+    const index = this.ids.length;
+    this.speciesSets.push(set);
+    this.localSlots.push(local);
+    this.reactionModels.push(model);
+    const conductivity = substance.conductivity ?? null;
+    this.conduction.push({ geometry, conductivity });
+    const shape = substance.shape ?? SHAPE_CYLINDER;
+    const perCount: (ConductionModel | null)[] = [null];
+    for (let count = 1; count <= geometry.count; count++) {
+      perCount.push({ geometry: shellGeometry(shape, count), conductivity });
+    }
+    this.byShellCount.push(perCount);
+    this.ids.push(substance.id);
+    this.byId.set(substance.id, index);
+    this.definitions.push(substance);
+    this.densities.push(substance.density);
+    this.porosities.push(substance.porosity ?? 0);
+    this.emissivities.push(substance.emissivity ?? 0.9);
+    this.ignitions.push(substance.ignition ?? null);
+    this.appearances.push(substance.appearance ?? null);
+    return index;
+  }
+
+  indexOf(id: string): number {
+    return this.byId.get(id) ?? -1;
+  }
+
+  idOf(substance: number): string {
+    return this.ids[this.check(substance)] as string;
+  }
+
+  conductionOf(substance: number): ConductionModel {
+    return this.conduction[this.check(substance)] as ConductionModel;
+  }
+
+  /**
+   * The conduction model for a substance resolved to `shells`, which a tier may have reduced it to.
+   *
+   * Precomputed at registration; see `byShellCount` for why it is not derived on demand.
+   */
+  conductionAt(substance: number, shells: number): ConductionModel {
+    const row = this.byShellCount[this.check(substance)] as (ConductionModel | null)[];
+    const model = shells >= 1 && shells < row.length ? row[shells] : null;
+    return model ?? (this.conduction[substance] as ConductionModel);
+  }
+
+  densityOf(substance: number): number {
+    return this.densities[this.check(substance)] as number;
+  }
+
+  /** Void fraction, 0..1. Zero means it exchanges no gas with the air at all. */
+  porosityOf(substance: number): number {
+    return this.porosities[this.check(substance)] as number;
+  }
+
+  /** How readily it radiates and absorbs, 0..1. */
+  emissivityOf(substance: number): number {
+    return this.emissivities[this.check(substance)] as number;
+  }
+
+  /** When this material catches, or `null` where nobody said it does. */
+  ignitionOf(substance: number): IgnitionModel | null {
+    return this.ignitions[this.check(substance)] as IgnitionModel | null;
+  }
+
+  /**
+   * What it looks like, or `null` where nobody said.
+   *
+   * `null` rather than a grey default: `present/` writes nothing for a substance with no appearance
+   * rather than inventing one, so a consumer sees their own material unchanged instead of finding
+   * the engine has quietly recoloured it.
+   */
+  appearanceOf(substance: number): AppearanceModel | null {
+    return this.appearances[this.check(substance)] as AppearanceModel | null;
+  }
+
+  definitionOf(substance: number): SubstanceThermal {
+    return this.definitions[this.check(substance)] as SubstanceThermal;
+  }
+
+  /** Global species indices this substance's parcels carry, ascending. */
+  speciesSetOf(substance: number): Int32Array {
+    return this.speciesSets[this.check(substance)] as Int32Array;
+  }
+
+  /** The local slot a global species occupies for this substance, or -1. */
+  localSlotOf(substance: number, species: number): number {
+    const row = this.localSlots[this.check(substance)] as Int32Array;
+    return species >= 0 && species < row.length ? (row[species] as number) : -1;
+  }
+
+  reactionsOf(substance: number): SubstanceReactions {
+    return this.reactionModels[this.check(substance)] as SubstanceReactions;
+  }
+
+  /**
+   * The species set and the localised, packed reaction network.
+   *
+   * The set is the composition's species plus everything its reactions touch, so a shell's
+   * composition is a dense run of the few species it can hold rather than a row over all
+   * sixty-eight. Built here, once, because it is a property of the substance.
+   */
+  private buildReactions(substance: SubstanceThermal): {
+    set: Int32Array;
+    local: Int32Array;
+    model: SubstanceReactions;
+  } {
+    const ids = substance.reactions ?? [];
+
+    const present = new Set<number>();
+    for (const s of substance.composition.species) present.add(s);
+    if (this.reactions !== undefined) {
+      for (const id of ids) {
+        const r = this.reactions.indexOf(id);
+        if (r < 0)
+          throw new Error(
+            `substance "${substance.id}" declares reaction "${id}", which is not registered`,
+          );
+        for (const sp of this.reactions.reactantSpecies(r)) present.add(sp);
+        for (const sp of this.reactions.productSpecies(r)) present.add(sp);
+      }
+    } else if (ids.length > 0) {
+      throw new Error(
+        `substance "${substance.id}" declares reactions, and this registry was built with none`,
+      );
+    }
+    const set = Int32Array.from([...present].sort((a, b) => a - b));
+    if (set.length > MAX_SUBSTANCE_SPECIES) {
+      throw new Error(
+        `substance "${substance.id}" would track ${set.length} species; the limit is ${MAX_SUBSTANCE_SPECIES}`,
+      );
+    }
+    const local = new Int32Array(this.species.count).fill(-1);
+    for (let i = 0; i < set.length; i++) local[set[i] as number] = i;
+
+    return {
+      set,
+      local,
+      model: localiseReactions(
+        this.species,
+        this.reactions,
+        ids,
+        set,
+        `substance "${substance.id}"`,
+      ),
+    };
+  }
+
+  private check(substance: number): number {
+    if (!Number.isInteger(substance) || substance < 0 || substance >= this.ids.length) {
+      throw new Error(`substance ${substance} is outside a registry of ${this.ids.length}`);
+    }
+    return substance;
+  }
+}

package/src/substance/substance.ts

@@ -0,0 +1,148 @@
+/**
+ * What a material is, thermally: a composition, a density, and the transitions it passes through.
+ *
+ * CH-1's half of `Substance`. The design's `§5` describes the whole of it — conductivity,
+ * emissivity, porosity, shells, reactions, ignition, appearance — and each field arrives with the
+ * phase that reads it. Declaring them all here with nothing reading them would be the speculative
+ * abstraction `AGENTS.md` §Module rules forbids.
+ */
+import { ELEMENT_COUNT } from '../element/elements.ts';
+import type { SpeciesRegistry } from '../species/registry.ts';
+import { type Composition, massFractions } from './composition.ts';
+import type { Conductivity } from '../parcel/conduction.ts';
+import type { Shape } from '../parcel/shells.ts';
+import type { IgnitionModel } from '../ignition/criteria.ts';
+
+/*
+ * **`PhaseTransition` is gone, and `phaseChange` in `reaction/reaction.ts` is where it went.**
+ *
+ * It described melting and boiling as shape in a per-substance enthalpy curve, and CH-6 retired
+ * that curve: the latent heat is already in the formation enthalpies CH-0 stores, so a phase change
+ * is a reaction with a temperature gate and its plateau emerges from the solver everything else
+ * already uses. A substance declares it in `reactions` like anything else it can do.
+ */
+
+export interface SubstanceThermal {
+  readonly id: string;
+  /**
+   * What it is made of **at the bottom of the curve**, as mass fractions summing to one.
+   *
+   * The rule matters and is not obvious: transitions are applied in ascending temperature order, so
+   * a substance is authored as its coldest form. Water is `H2O(s)` with two transitions, not
+   * `H2O(l)` with one in each direction. A transition whose source species is absent when it is
+   * reached is refused, naming both, rather than silently doing nothing.
+   */
+  readonly composition: Composition;
+  /** kg/m³ of the dry matter. */
+  readonly density: number;
+  /**
+   * W/(m·K), rising with temperature. **Optional, and conduction refuses a substance without one**,
+   * naming it — a thermal conductivity nobody stated is a number somebody invented, and it decides
+   * whether a log takes twenty seconds or twenty minutes.
+   */
+  readonly conductivity?: Conductivity;
+  /** How many nested shells of equal mass. Four by default; see `§4` for why not one and why not sixteen. */
+  readonly shells?: number;
+  /** What it is shaped like, which decides how those shells divide. A cylinder by default: a log. */
+  readonly shape?: Shape;
+  /**
+   * Void fraction, 0..1. What decides how freely gas moves between this material and the air.
+   *
+   * A charcoal briquette breathes and a pane of glass does not, and that is most of the difference
+   * between something that smoulders and something that does not. Zero by default, which means a
+   * substance exchanges no gas at all until somebody says how open it is.
+   */
+  readonly porosity?: number;
+  /** How readily it radiates and absorbs, 0..1. Most non-metals sit near 0.9, which is the default. */
+  readonly emissivity?: number;
+  /**
+   * Reactions this material can undergo, by id.
+   *
+   * A substance's parcels track masses for its composition species **plus every species these
+   * reactions touch**, so declaring one is what makes room for its products. Wood that pyrolyses
+   * holds char and steam it did not start with.
+   */
+  readonly reactions?: readonly string[];
+  /**
+   * When this material catches and when it stops.
+   *
+   * Absent means it never catches at all, which is the right default: a substance nobody described
+   * as flammable should not be, and inventing an ignition temperature for glass is worse than
+   * declining to have one.
+   */
+  readonly ignition?: IgnitionModel;
+  /**
+   * What it looks like, and every field is a measurable property of the material rather than a
+   * choice about how to draw it.
+   *
+   * Absent means a consumer supplies their own colours, which is the right default: a substance
+   * nobody described the appearance of should not have one invented for it. `present/` refuses to
+   * write an albedo it was never given rather than writing grey.
+   */
+  readonly appearance?: AppearanceModel;
+}
+
+/**
+ * `§17`'s three numbers: what a material looks like before it burns, after it burns, and how dirty
+ * its smoke is on the way.
+ *
+ * **Soot yield belongs on the substance and `§8.4` says why**: polystyrene sooting heavily and
+ * methanol burning invisibly are the two ends of a scale, and which end a fuel sits at is a property
+ * of the fuel. It is the one number that decides whether a fire is seen at all in daylight.
+ */
+export interface AppearanceModel {
+  /** Linear RGB before anything happens to it. */
+  readonly albedo: readonly [number, number, number];
+  /** Linear RGB when it is entirely char. Near-black for anything that chars at all. */
+  readonly charAlbedo: readonly [number, number, number];
+  /** kg of soot per kg of volatiles burnt. Wood is about 0.015; polystyrene is 0.16. */
+  readonly sootYield: number;
+}
+
+/**
+ * A composition with dry-basis moisture folded into it.
+ *
+ * **"12% moisture content" means 12 kg of water per 100 kg of *dry* matter**, so water is
+ * `m / (1 + m)` of the whole and every dry component is scaled by `1 / (1 + m)`. Treating the
+ * figure as a wet-basis fraction is wrong by 1.4 points at 12% and by 33 points for green wood at
+ * 60%, which is exactly the range where it decides whether a log catches fire at all.
+ *
+ * Water the composition already held is added to rather than replaced, because a substance can be
+ * authored wet: a stew is mostly water before anybody adds moisture to it.
+ */
+export function wetComposition(
+  registry: SpeciesRegistry,
+  dry: Composition,
+  moisture: number,
+): Composition {
+  if (!Number.isFinite(moisture) || moisture < 0) {
+    throw new Error(`moisture content is ${moisture}, which is not a non-negative number`);
+  }
+  if (moisture === 0) return dry;
+
+  const scale = 1 / (1 + moisture);
+  const entries: Record<string, number> = {};
+  for (let i = 0; i < dry.species.length; i++) {
+    entries[registry.idOf(dry.species[i] as number)] = (dry.fraction[i] as number) * scale;
+  }
+  const water = 'H2O(l)';
+  entries[water] = (entries[water] ?? 0) + moisture * scale;
+  return massFractions(registry, entries);
+}
+
+/** Moles of each element in one kilogram of a composition. Writes into `out`, allocates nothing. */
+export function compositionElements(
+  registry: SpeciesRegistry,
+  composition: Composition,
+  out: Float64Array,
+): void {
+  if (out.length !== ELEMENT_COUNT) {
+    throw new Error(`a totals vector is ${ELEMENT_COUNT} wide, not ${out.length}`);
+  }
+  out.fill(0);
+  for (let i = 0; i < composition.species.length; i++) {
+    const species = composition.species[i] as number;
+    const kilograms = composition.fraction[i] as number;
+    registry.elements.addScaledRow(species, kilograms / registry.molarMass(species), out);
+  }
+}

package/src/testing/drift.ts

@@ -0,0 +1,28 @@
+/**
+ * How far two element vectors have drifted apart, for the conservation harness.
+ *
+ * Relative rather than absolute, because the elements in a burning world span many orders of
+ * magnitude at once: a scene may hold a kilomole of nitrogen and a micromole of sulphur, and an
+ * absolute tolerance either passes on a broken sulphur balance or fails on a correct nitrogen one.
+ *
+ * **With one exception that matters.** Where both sides are effectively zero, a relative measure
+ * has nothing to divide by — and an element that appeared from nowhere would then report as no
+ * drift at all, which is the single failure this harness exists to catch. So the denominator has a
+ * floor of one, making the measure absolute in that regime.
+ *
+ * Test-side rather than runtime: nothing in the simulation calls it.
+ */
+export function maxElementDrift(a: Float64Array, b: Float64Array): number {
+  if (a.length !== b.length) {
+    throw new Error(`element vectors are ${a.length} and ${b.length} wide`);
+  }
+  let worst = 0;
+  for (let i = 0; i < a.length; i++) {
+    const left = a[i] as number;
+    const right = b[i] as number;
+    const scale = Math.max(1, Math.abs(left), Math.abs(right));
+    const drift = Math.abs(left - right) / scale;
+    if (drift > worst) worst = drift;
+  }
+  return worst;
+}

package/src/transport/contacts.ts

@@ -0,0 +1,56 @@
+/**
+ * Which parcels are touching, this tick.
+ *
+ * Refilled by the caller each tick rather than held, the same shape `RadiativeSources` takes and
+ * for the same reason: contact is a property of the world's arrangement, which this package does
+ * not know. In practice it is fed from Track B's contact event buffer, which already reports pairs
+ * by feature id — and feeding it is the whole of what a consumer does to make a pan heat a steak.
+ */
+export class ContactSet {
+  private a = new Int32Array(32);
+  private b = new Int32Array(32);
+  private area = new Float64Array(32);
+  private used = 0;
+
+  get count(): number {
+    return this.used;
+  }
+
+  clear(): void {
+    this.used = 0;
+  }
+
+  /** @param area m² of shared surface, which is what sets how fast heat crosses. */
+  add(a: number, b: number, area: number): void {
+    if (this.used === this.a.length) this.grow();
+    const at = this.used++;
+    this.a[at] = a;
+    this.b[at] = b;
+    this.area[at] = area;
+  }
+
+  firstOf(contact: number): number {
+    return this.a[contact] as number;
+  }
+
+  secondOf(contact: number): number {
+    return this.b[contact] as number;
+  }
+
+  areaOf(contact: number): number {
+    return this.area[contact] as number;
+  }
+
+  private grow(): void {
+    const size = this.a.length * 2;
+    const a = new Int32Array(size);
+    a.set(this.a);
+    this.a = a;
+    const b = new Int32Array(size);
+    b.set(this.b);
+    this.b = b;
+    const area = new Float64Array(size);
+    area.set(this.area);
+    this.area = area;
+  }
+}

package/src/transport/radiation.ts

@@ -0,0 +1,238 @@
+/**
+ * Heat crossing empty space, which is how a fire reaches anything it is not touching.
+ *
+ * **Radiation dominates every fire beyond a few centimetres, and `§10` is the argument.** A flame
+ * at 1200 K radiates about 118 kW/m², and the fourth power means halving its temperature cuts that
+ * sixteenfold. A model without it cannot make a log ignite from across a hearth — which is the
+ * scenario the whole track exists for.
+ *
+ * **The view factor is a point source: `cos θ · A / (π r²)`.** It is wrong close in, where a flame
+ * is not a point, and it is right where it matters. What it buys is the single relationship this
+ * model is built on: **flux falls as `1/r²`**, so moving a log twice as far from a fire makes it
+ * take four times as long to catch. One line of arithmetic, and without it "leading a piece of wood
+ * near the fire" has no right answer at all.
+ */
+
+/** W/(m²·K⁴). */
+export const STEFAN_BOLTZMANN = 5.670374419e-8;
+
+/**
+ * How close a point source may be approached before the approximation is capped.
+ *
+ * A point source's flux is unbounded at zero distance, and the honest failure there is a large
+ * number rather than an infinite one. The clamp is the scale at which a real source stops looking
+ * like a point, which is its own size.
+ */
+const MIN_DISTANCE = 0.05;
+
+/**
+ * Radiant flux onto a surface, W/m².
+ *
+ * @param sourceTemperature K
+ * @param sourceArea m² of radiating surface
+ * @param surfaceTemperature K of the receiver
+ * @param emissivity of the receiver, 0..1
+ * @param distance m
+ * @param cosine of the angle between the receiver's normal and the line to the source
+ */
+export function radiantFlux(
+  sourceTemperature: number,
+  sourceArea: number,
+  surfaceTemperature: number,
+  emissivity: number,
+  distance: number,
+  cosine: number,
+): number {
+  if (!(cosine > 0)) return 0;
+  const range = Math.max(distance, MIN_DISTANCE);
+  const viewFactor = (cosine * sourceArea) / (Math.PI * range * range);
+  const source = sourceTemperature * sourceTemperature * sourceTemperature * sourceTemperature;
+  const surface = surfaceTemperature * surfaceTemperature * surfaceTemperature * surfaceTemperature;
+  return emissivity * STEFAN_BOLTZMANN * viewFactor * (source - surface);
+}
+
+/**
+ * How far a source of a given power is worth considering, m.
+ *
+ * From `P / (4π r²) = q_min`, so a **big fire reaches further than a small one** rather than every
+ * source sharing a constant radius. That is what stops a candle being tested against every parcel
+ * in a scene and a bonfire being cut off at the same distance.
+ */
+export function sourceRange(power: number, minimumFlux: number): number {
+  if (!(power > 0) || !(minimumFlux > 0)) return 0;
+  return Math.sqrt(power / (4 * Math.PI * minimumFlux));
+}
+
+/**
+ * Convective heat transfer coefficient from the local gas speed, W/(m²·K).
+ *
+ * Two to twenty-five in still air, and up to about two hundred and fifty in a gale. **Above a fire
+ * convection dominates radiation and beside one radiation dominates convection**, and the crossover
+ * is at the plume edge — which is why standing beside a bonfire is pleasant and standing in the
+ * smoke is not.
+ */
+export function convectiveCoefficient(gasSpeed: number): number {
+  const speed = gasSpeed > 0 ? gasSpeed : 0;
+  const h = 5 + 12 * Math.sqrt(speed);
+  return h > 250 ? 250 : h;
+}
+
+/** Whether anything solid stands between two points. */
+export type OcclusionTest = (
+  ax: number,
+  ay: number,
+  az: number,
+  bx: number,
+  by: number,
+  bz: number,
+) => boolean;
+
+/** Below this a source is not worth testing against anything, W/m². */
+const MINIMUM_USEFUL_FLUX = 200;
+
+/**
+ * The radiating things in a scene this tick: flames and hot surfaces both.
+ *
+ * Gathered into columns once per tick and read many times, which is why it is a structure rather
+ * than a callback. Cleared and refilled rather than reallocated.
+ */
+export class RadiativeSources {
+  private x = new Float64Array(32);
+  private y = new Float64Array(32);
+  private z = new Float64Array(32);
+  private temperature = new Float64Array(32);
+  private area = new Float64Array(32);
+  private range = new Float64Array(32);
+  private used = 0;
+
+  get count(): number {
+    return this.used;
+  }
+
+  clear(): void {
+    this.used = 0;
+  }
+
+  /** @param power W, which decides how far this source is worth testing against. */
+  add(x: number, y: number, z: number, temperature: number, area: number, power: number): void {
+    if (this.used === this.x.length) this.grow();
+    const at = this.used++;
+    this.x[at] = x;
+    this.y[at] = y;
+    this.z[at] = z;
+    this.temperature[at] = temperature;
+    this.area[at] = area;
+    this.range[at] = sourceRange(power, MINIMUM_USEFUL_FLUX);
+  }
+
+  temperatureOf(source: number): number {
+    return this.temperature[source] as number;
+  }
+
+  areaOf(source: number): number {
+    return this.area[source] as number;
+  }
+
+  /** Whether a point is inside this source's own reach. */
+  reaches(source: number, x: number, y: number, z: number): boolean {
+    const dx = x - (this.x[source] as number);
+    const dy = y - (this.y[source] as number);
+    const dz = z - (this.z[source] as number);
+    const reach = this.range[source] as number;
+    return dx * dx + dy * dy + dz * dz <= reach * reach;
+  }
+
+  /**
+   * Total flux onto a point from every source that can see it, W/m².
+   *
+   * The receiver is treated as facing each source — a parcel is a lump rather than a plane, so
+   * there is no one normal to take a cosine against. What that costs is that a flat plate edge-on
+   * to a fire receives as much as one facing it; what it buys is not asking a consumer for a normal
+   * per parcel, which is a number most of them do not have.
+   */
+  fluxAt(
+    x: number,
+    y: number,
+    z: number,
+    surfaceTemperature: number,
+    emissivity: number,
+    occluded: OcclusionTest | null,
+  ): number {
+    let total = 0;
+    for (let source = 0; source < this.used; source++) {
+      if (!this.reaches(source, x, y, z)) continue;
+      const sx = this.x[source] as number;
+      const sy = this.y[source] as number;
+      const sz = this.z[source] as number;
+      if (occluded !== null && occluded(sx, sy, sz, x, y, z)) continue;
+      const dx = x - sx;
+      const dy = y - sy;
+      const dz = z - sz;
+      total += radiantFlux(
+        this.temperature[source] as number,
+        this.area[source] as number,
+        surfaceTemperature,
+        emissivity,
+        Math.sqrt(dx * dx + dy * dy + dz * dz),
+        1,
+      );
+    }
+    return total;
+  }
+
+  /**
+   * The temperature of the hottest source that reaches a point, or zero where none does.
+   *
+   * **What a radiative exchange is bounded by**, and the reason it has to be bounded at all: the
+   * radiative term is explicit, so a parcel whose surface shell has a small heat capacity — a coin,
+   * a nail, a leaf — can absorb more in one step than would take it past the source that is heating
+   * it, and then radiate the excess back as `T⁴` and ring itself to pieces. It was found by putting
+   * a copper coin on a hearth in `demo/dev/chemistry.ts`, where it reached 4,000 K on the first step
+   * and 100 K a minute later.
+   *
+   * Nothing can be heated past the thing heating it, so this is the equilibrium the step may reach
+   * and not exceed — which is what an implicit solve would give and costs one comparison per source.
+   */
+  hottestAt(x: number, y: number, z: number, occluded: OcclusionTest | null): number {
+    let hottest = 0;
+    for (let source = 0; source < this.used; source++) {
+      if (!this.reaches(source, x, y, z)) continue;
+      const sx = this.x[source] as number;
+      const sy = this.y[source] as number;
+      const sz = this.z[source] as number;
+      if (occluded !== null && occluded(sx, sy, sz, x, y, z)) continue;
+      const temperature = this.temperature[source] as number;
+      if (temperature > hottest) hottest = temperature;
+    }
+    return hottest;
+  }
+
+  /**
+   * Whether **any** source reaches a point at all, which is the whole of the wake test.
+   *
+   * `§14`'s scan has to be coarse or sleeping saves nothing: this is a range comparison per source
+   * and no view factor, no temperature and no occlusion ray. A source's range already comes from its
+   * own power, so a bonfire wakes a parcel a candle would not.
+   */
+  reachesPoint(x: number, y: number, z: number): boolean {
+    for (let source = 0; source < this.used; source++) {
+      if (this.reaches(source, x, y, z)) return true;
+    }
+    return false;
+  }
+
+  private grow(): void {
+    const size = this.x.length * 2;
+    const grow = (from: Float64Array<ArrayBuffer>): Float64Array<ArrayBuffer> => {
+      const to = new Float64Array(size);
+      to.set(from);
+      return to;
+    };
+    this.x = grow(this.x);
+    this.y = grow(this.y);
+    this.z = grow(this.z);
+    this.temperature = grow(this.temperature);
+    this.area = grow(this.area);
+    this.range = grow(this.range);
+  }
+}