@classytic/stage 0.3.0 → 0.4.0

package/dist/chem/chromatography.d.mts

@@ -0,0 +1,66 @@
+//#region src/chem/chromatography.d.ts
+/**
+ * chromatography, identifying a component by where it stops.
+ *
+ * WHAT THIS IS FOR. The arithmetic of a retention factor is one division, and one division is not an
+ * engine. What is worth computing is the IDENTIFICATION: given a set of reference values and a spot,
+ * which references does it match, and is that match unique?
+ *
+ * The answer is often "not unique", and that is the whole reason a second solvent exists. A learner
+ * told to run two solvents without being shown a case where one fails has been given a ritual. So
+ * {@link identify} reports ambiguity as a result rather than hiding it, and {@link resolvedBy} finds
+ * the solvent that breaks a tie.
+ *
+ * ## Why a tolerance, and why it is not optional
+ *
+ * An Rf is reproducible to about ±0.02 in practice, and less than that if the tank was not saturated
+ * or the temperature drifted. Matching on exact equality would make every real measurement fail and
+ * would teach that chromatography is more precise than it is. The tolerance is a parameter because
+ * it is a property of the experiment, not of the chemistry.
+ *
+ * Pure: no React, no pixels.
+ */
+/** A substance and where it stops in each solvent the lab offers. */
+interface Component {
+  readonly id: string;
+  readonly name: string;
+  /** Retention factor in each solvent, keyed by solvent id. Always between 0 and 1. */
+  readonly rf: Readonly<Record<string, number>>;
+}
+/**
+ * The retention factor: how far the spot went as a fraction of how far the solvent went.
+ *
+ * Both distances are measured from the pencil baseline. Refuses a spot that has overtaken the
+ * solvent front, which is not a measurement error to round away: it means the distances were
+ * measured from different places, usually the bottom of the plate rather than the baseline.
+ */
+declare function retentionFactor(spotCm: number, frontCm: number): number;
+/** Where a component's spot sits, given how far the solvent has run. */
+declare const spotDistance: (component: Component, solvent: string, frontCm: number) => number;
+/** What an identification attempt produced. */
+interface Identification {
+  /** Every reference within tolerance, best match first. */
+  readonly matches: readonly Component[];
+  /** True when exactly one reference matches, so the spot is named. */
+  readonly unique: boolean;
+}
+/**
+ * Which references a measured Rf could be.
+ *
+ * Returns every candidate rather than the closest one. A spot that sits between two references has
+ * not identified anything, and reporting the nearest would turn a failed experiment into a confident
+ * wrong answer.
+ */
+declare function identify(rf: number, references: readonly Component[], solvent: string, tolerance?: number): Identification;
+/**
+ * A solvent in which two components can be told apart, or `undefined` if none can.
+ *
+ * This is the argument for running a second solvent, made as a computation. Two components that sit
+ * on top of each other in one solvent will usually separate in another, because the competition
+ * between the phases depends on the solvent as much as on the substance.
+ */
+declare function resolvedBy(a: Component, b: Component, solvents: readonly string[], tolerance?: number): string | undefined;
+/** Pairs that cannot be told apart in a given solvent, which is what makes a mixture ambiguous. */
+declare function unresolvedPairs(components: readonly Component[], solvent: string, tolerance?: number): [Component, Component][];
+//#endregion
+export { Component, Identification, identify, resolvedBy, retentionFactor, spotDistance, unresolvedPairs };

package/dist/chem/chromatography.mjs

@@ -0,0 +1,63 @@
+//#region src/chem/chromatography.ts
+/**
+* The retention factor: how far the spot went as a fraction of how far the solvent went.
+*
+* Both distances are measured from the pencil baseline. Refuses a spot that has overtaken the
+* solvent front, which is not a measurement error to round away: it means the distances were
+* measured from different places, usually the bottom of the plate rather than the baseline.
+*/
+function retentionFactor(spotCm, frontCm) {
+	if (frontCm <= 0) throw new Error("The solvent front has not moved, so there is no Rf to report.");
+	if (spotCm < 0) throw new Error("A spot cannot move backwards from the baseline.");
+	if (spotCm > frontCm) throw new Error(`A spot at ${spotCm} cm cannot be past a front at ${frontCm} cm: the solvent carries it, so Rf is at most 1. Measure both from the pencil baseline.`);
+	return spotCm / frontCm;
+}
+/** Where a component's spot sits, given how far the solvent has run. */
+const spotDistance = (component, solvent, frontCm) => {
+	const rf = component.rf[solvent];
+	if (rf === void 0) throw new Error(`${component.name} has no measured Rf in ${solvent}.`);
+	return rf * frontCm;
+};
+/**
+* Which references a measured Rf could be.
+*
+* Returns every candidate rather than the closest one. A spot that sits between two references has
+* not identified anything, and reporting the nearest would turn a failed experiment into a confident
+* wrong answer.
+*/
+function identify(rf, references, solvent, tolerance = .03) {
+	const matches = references.filter((c) => c.rf[solvent] !== void 0 && Math.abs(c.rf[solvent] - rf) <= tolerance).sort((a, b) => Math.abs(a.rf[solvent] - rf) - Math.abs(b.rf[solvent] - rf));
+	return {
+		matches,
+		unique: matches.length === 1
+	};
+}
+/**
+* A solvent in which two components can be told apart, or `undefined` if none can.
+*
+* This is the argument for running a second solvent, made as a computation. Two components that sit
+* on top of each other in one solvent will usually separate in another, because the competition
+* between the phases depends on the solvent as much as on the substance.
+*/
+function resolvedBy(a, b, solvents, tolerance = .03) {
+	return solvents.find((s) => {
+		const ra = a.rf[s];
+		const rb = b.rf[s];
+		return ra !== void 0 && rb !== void 0 && Math.abs(ra - rb) > tolerance;
+	});
+}
+/** Pairs that cannot be told apart in a given solvent, which is what makes a mixture ambiguous. */
+function unresolvedPairs(components, solvent, tolerance = .03) {
+	const out = [];
+	for (let i = 0; i < components.length; i += 1) for (let j = i + 1; j < components.length; j += 1) {
+		const a = components[i];
+		const b = components[j];
+		const ra = a.rf[solvent];
+		const rb = b.rf[solvent];
+		if (ra !== void 0 && rb !== void 0 && Math.abs(ra - rb) <= tolerance) out.push([a, b]);
+	}
+	return out;
+}
+
+//#endregion
+export { identify, resolvedBy, retentionFactor, spotDistance, unresolvedPairs };

package/dist/chem/complex.d.mts

@@ -0,0 +1,114 @@
+//#region src/chem/complex.d.ts
+/**
+ * complex, the geometry and colour of a transition-metal complex ion.
+ *
+ * Three questions the syllabus asks about every complex, and they are all answered from the same
+ * declaration: what shape is it, how many isomers has it, and why is it that colour.
+ *
+ * ## Coordination number is not the number of ligands
+ *
+ * It is the number of COORDINATE BONDS, so a bidentate ligand counts twice. That single sentence
+ * settles a question learners routinely get wrong: [Cu(en)₂]²⁺ has two ligands and a coordination
+ * number of four, and [Cr(C₂O₄)₃]³⁻ has three ligands and a coordination number of six.
+ *
+ * ## Why shape follows from the number and not from the metal, except when it does not
+ *
+ * Six is octahedral and two is linear, with no exceptions worth teaching. Four is the interesting
+ * one: usually tetrahedral, but square planar for platinum and palladium. That is not a detail. A
+ * square-planar complex shows cis-trans isomerism and a tetrahedral one CANNOT, because in a
+ * tetrahedron every position is adjacent to every other, so there is no "opposite" to be trans to.
+ *
+ * Cisplatin is the case that matters: it is the cis isomer of a square-planar platinum complex and
+ * it is a cancer drug, while the trans isomer is not. Had the geometry been tetrahedral there would
+ * have been no two isomers to tell apart.
+ *
+ * ## Colour is what is NOT absorbed
+ *
+ * A d-block ion's d orbitals split, and the gap ΔE corresponds to a wavelength in the visible
+ * range. The ion absorbs that wavelength and what reaches the eye is the rest, which is why copper
+ * sulfate is blue BECAUSE it absorbs orange. Stating it the other way round, that it is blue
+ * because it absorbs blue, is the commonest sentence in a wrong answer.
+ *
+ * Pure: no React, no pixels.
+ */
+/** Planck constant, J s. */
+declare const PLANCK = 6.626e-34;
+/** Speed of light, m/s. */
+declare const LIGHT_SPEED = 299800000;
+/** Avogadro constant, per mole. */
+declare const AVOGADRO = 6.022e+23;
+type Geometry = 'linear' | 'tetrahedral' | 'square-planar' | 'octahedral';
+interface Ligand {
+  readonly name: string;
+  /** As it appears inside the square brackets. */
+  readonly formula: string;
+  /** Charge on the ligand itself. 0 for a neutral one. */
+  readonly charge: number;
+  /** Coordinate bonds it forms. 2 for a bidentate ligand. */
+  readonly denticity: number;
+}
+/** The ligands the syllabus actually uses. */
+declare const LIGANDS: Readonly<Record<string, Ligand>>;
+interface ComplexSpec {
+  /** Symbol of the central metal, e.g. 'Cu'. */
+  readonly metal: string;
+  /** Its oxidation number. */
+  readonly oxidation: number;
+  readonly ligands: readonly {
+    readonly ligand: Ligand;
+    readonly count: number;
+  }[];
+  /**
+   * Force a geometry the coordination number would not give.
+   *
+   * Only ever needed at four, where platinum and palladium are square planar and everything else is
+   * tetrahedral. Provided as an override rather than a longer metal table, because the exceptions
+   * are a syllabus fact rather than a rule anyone can derive.
+   */
+  readonly geometry?: Geometry;
+}
+/** Coordinate bonds, NOT the number of ligands. A bidentate ligand counts twice. */
+declare const coordinationNumber: (spec: ComplexSpec) => number;
+/** Overall charge: the metal's oxidation number plus every ligand's own charge. */
+declare const complexCharge: (spec: ComplexSpec) => number;
+declare function geometryOf(spec: ComplexSpec): Geometry;
+/** The bond angle a shape gives, in degrees. */
+declare function bondAngle(geometry: Geometry): number;
+/** `[Cu(H2O)6]2+`, with the charge written the way a data book writes it. */
+declare function complexFormula(spec: ComplexSpec): string;
+interface StereoResult {
+  readonly count: number;
+  /** 'cis', 'trans', 'fac', 'mer', 'optical pair'. */
+  readonly kinds: readonly string[];
+  /** Why there are that many, in a sentence a mark scheme would accept. */
+  readonly reason: string;
+}
+/**
+ * How many stereoisomers a complex has, and what kind.
+ *
+ * Covers the shapes the syllabus sets and refuses to guess beyond them. The important NEGATIVE
+ * result is the tetrahedral one: no cis-trans isomerism at any composition, because a tetrahedron
+ * has no two positions opposite each other.
+ */
+declare function stereoisomers(spec: ComplexSpec): StereoResult;
+/** The splitting energy ΔE for light of this wavelength, in joules per photon. */
+declare const splittingEnergy: (wavelengthNm: number) => number;
+/** The same energy per mole, in kJ/mol, which is the form a question asks for. */
+declare const splittingEnergyPerMole: (wavelengthNm: number) => number;
+/** The wavelength whose photon energy is ΔE joules. */
+declare const wavelengthFor: (joules: number) => number;
+interface ColourResult {
+  readonly absorbed: string;
+  readonly seen: string;
+  readonly wavelengthNm: number;
+}
+/**
+ * What colour a solution looks, given the wavelength it absorbs.
+ *
+ * The answer is the COMPLEMENTARY colour, never the absorbed one. Copper sulfate absorbs orange
+ * light at about 600 nm and therefore looks blue, and a learner who says it looks blue because it
+ * absorbs blue has the physics exactly backwards.
+ */
+declare function observedColour(wavelengthNm: number): ColourResult;
+//#endregion
+export { AVOGADRO, ColourResult, ComplexSpec, Geometry, LIGANDS, LIGHT_SPEED, Ligand, PLANCK, StereoResult, bondAngle, complexCharge, complexFormula, coordinationNumber, geometryOf, observedColour, splittingEnergy, splittingEnergyPerMole, stereoisomers, wavelengthFor };

package/dist/chem/complex.mjs

@@ -0,0 +1,234 @@
+//#region src/chem/complex.ts
+/**
+* complex, the geometry and colour of a transition-metal complex ion.
+*
+* Three questions the syllabus asks about every complex, and they are all answered from the same
+* declaration: what shape is it, how many isomers has it, and why is it that colour.
+*
+* ## Coordination number is not the number of ligands
+*
+* It is the number of COORDINATE BONDS, so a bidentate ligand counts twice. That single sentence
+* settles a question learners routinely get wrong: [Cu(en)₂]²⁺ has two ligands and a coordination
+* number of four, and [Cr(C₂O₄)₃]³⁻ has three ligands and a coordination number of six.
+*
+* ## Why shape follows from the number and not from the metal, except when it does not
+*
+* Six is octahedral and two is linear, with no exceptions worth teaching. Four is the interesting
+* one: usually tetrahedral, but square planar for platinum and palladium. That is not a detail. A
+* square-planar complex shows cis-trans isomerism and a tetrahedral one CANNOT, because in a
+* tetrahedron every position is adjacent to every other, so there is no "opposite" to be trans to.
+*
+* Cisplatin is the case that matters: it is the cis isomer of a square-planar platinum complex and
+* it is a cancer drug, while the trans isomer is not. Had the geometry been tetrahedral there would
+* have been no two isomers to tell apart.
+*
+* ## Colour is what is NOT absorbed
+*
+* A d-block ion's d orbitals split, and the gap ΔE corresponds to a wavelength in the visible
+* range. The ion absorbs that wavelength and what reaches the eye is the rest, which is why copper
+* sulfate is blue BECAUSE it absorbs orange. Stating it the other way round, that it is blue
+* because it absorbs blue, is the commonest sentence in a wrong answer.
+*
+* Pure: no React, no pixels.
+*/
+/** Planck constant, J s. */
+const PLANCK = 6626e-37;
+/** Speed of light, m/s. */
+const LIGHT_SPEED = 2998e5;
+/** Avogadro constant, per mole. */
+const AVOGADRO = 6022e20;
+const ligand = (name, formula, charge, denticity = 1) => ({
+	name,
+	formula,
+	charge,
+	denticity
+});
+/** The ligands the syllabus actually uses. */
+const LIGANDS = {
+	water: ligand("water", "H2O", 0),
+	ammonia: ligand("ammonia", "NH3", 0),
+	chloride: ligand("chloride", "Cl", -1),
+	cyanide: ligand("cyanide", "CN", -1),
+	hydroxide: ligand("hydroxide", "OH", -1),
+	/** 1,2-diaminoethane, the standard neutral bidentate ligand. */
+	en: ligand("1,2-diaminoethane", "en", 0, 2),
+	/** Ethanedioate, the standard charged bidentate ligand. */
+	ethanedioate: ligand("ethanedioate", "C2O4", -2, 2)
+};
+/** Metals that are square planar at coordination number four. */
+const SQUARE_PLANAR = new Set(["Pt", "Pd"]);
+/** Coordinate bonds, NOT the number of ligands. A bidentate ligand counts twice. */
+const coordinationNumber = (spec) => spec.ligands.reduce((n, l) => n + l.count * l.ligand.denticity, 0);
+/** Overall charge: the metal's oxidation number plus every ligand's own charge. */
+const complexCharge = (spec) => spec.ligands.reduce((q, l) => q + l.count * l.ligand.charge, spec.oxidation);
+function geometryOf(spec) {
+	if (spec.geometry) return spec.geometry;
+	const n = coordinationNumber(spec);
+	if (n === 6) return "octahedral";
+	if (n === 2) return "linear";
+	if (n === 4) return SQUARE_PLANAR.has(spec.metal) ? "square-planar" : "tetrahedral";
+	throw new Error(`Coordination number ${n} for ${spec.metal} has no shape in this kernel. The syllabus uses 2, 4 and 6.`);
+}
+/** The bond angle a shape gives, in degrees. */
+function bondAngle(geometry) {
+	switch (geometry) {
+		case "linear": return 180;
+		case "tetrahedral": return 109.5;
+		case "square-planar": return 90;
+		case "octahedral": return 90;
+	}
+}
+/** `[Cu(H2O)6]2+`, with the charge written the way a data book writes it. */
+function complexFormula(spec) {
+	const inner = spec.ligands.map((l) => l.count === 1 ? `(${l.ligand.formula})` : `(${l.ligand.formula})${l.count}`).join("");
+	const q = complexCharge(spec);
+	const sign = q === 0 ? "" : q > 0 ? `${Math.abs(q) === 1 ? "" : Math.abs(q)}+` : `${Math.abs(q) === 1 ? "" : Math.abs(q)}-`;
+	return `[${spec.metal}${inner}]${sign}`;
+}
+/**
+* How many stereoisomers a complex has, and what kind.
+*
+* Covers the shapes the syllabus sets and refuses to guess beyond them. The important NEGATIVE
+* result is the tetrahedral one: no cis-trans isomerism at any composition, because a tetrahedron
+* has no two positions opposite each other.
+*/
+function stereoisomers(spec) {
+	const geometry = geometryOf(spec);
+	const mono = spec.ligands.filter((l) => l.ligand.denticity === 1);
+	const bi = spec.ligands.filter((l) => l.ligand.denticity === 2);
+	const counts = mono.map((l) => l.count).sort((a, b) => b - a);
+	const biTotal = bi.reduce((n, l) => n + l.count, 0);
+	if (geometry === "linear") return {
+		count: 1,
+		kinds: [],
+		reason: "Two ligands on a straight line have only one arrangement."
+	};
+	if (geometry === "tetrahedral") return {
+		count: 1,
+		kinds: [],
+		reason: "A tetrahedron has no two positions opposite each other, so there is nothing for a ligand to be trans to. Tetrahedral complexes show no cis-trans isomerism at all."
+	};
+	if (geometry === "square-planar") {
+		if (counts.length === 2 && counts[0] === 2 && counts[1] === 2) return {
+			count: 2,
+			kinds: ["cis", "trans"],
+			reason: "Two pairs in a square: the identical ligands are either adjacent (cis) or opposite (trans). This is the cisplatin case, where only the cis isomer is the drug."
+		};
+		return {
+			count: 1,
+			kinds: [],
+			reason: "Only one arrangement of these ligands in a square."
+		};
+	}
+	if (biTotal === 3) return {
+		count: 2,
+		kinds: ["optical pair"],
+		reason: "Three bidentate ligands around an octahedron make a propeller, and a propeller has a handedness. The two forms are non-superimposable mirror images."
+	};
+	if (biTotal === 2 && counts.length === 1 && counts[0] === 2) return {
+		count: 3,
+		kinds: ["cis (optical pair)", "trans"],
+		reason: "The two single ligands are adjacent or opposite. The trans form has a mirror plane; the cis form does not, so it is itself a pair of optical isomers. Two plus one is three."
+	};
+	if (counts.length === 2 && counts[0] === 4 && counts[1] === 2) return {
+		count: 2,
+		kinds: ["cis", "trans"],
+		reason: "The two odd ligands sit next to each other (cis) or on opposite corners (trans)."
+	};
+	if (counts.length === 2 && counts[0] === 3 && counts[1] === 3) return {
+		count: 2,
+		kinds: ["fac", "mer"],
+		reason: "Three and three: the matching set occupies one triangular face (fac) or a meridian running around the ion (mer)."
+	};
+	if (counts.length === 1) return {
+		count: 1,
+		kinds: [],
+		reason: "Six identical ligands have one arrangement."
+	};
+	return {
+		count: 1,
+		kinds: [],
+		reason: "No stereoisomerism for this combination in the cases the syllabus sets."
+	};
+}
+/** The splitting energy ΔE for light of this wavelength, in joules per photon. */
+const splittingEnergy = (wavelengthNm) => PLANCK * LIGHT_SPEED / (wavelengthNm * 1e-9);
+/** The same energy per mole, in kJ/mol, which is the form a question asks for. */
+const splittingEnergyPerMole = (wavelengthNm) => splittingEnergy(wavelengthNm) * AVOGADRO / 1e3;
+/** The wavelength whose photon energy is ΔE joules. */
+const wavelengthFor = (joules) => PLANCK * LIGHT_SPEED / joules / 1e-9;
+const WHEEL = [
+	{
+		from: 400,
+		to: 435,
+		absorbed: "violet",
+		seen: "yellow-green"
+	},
+	{
+		from: 435,
+		to: 480,
+		absorbed: "blue",
+		seen: "yellow"
+	},
+	{
+		from: 480,
+		to: 490,
+		absorbed: "green-blue",
+		seen: "orange"
+	},
+	{
+		from: 490,
+		to: 500,
+		absorbed: "blue-green",
+		seen: "red"
+	},
+	{
+		from: 500,
+		to: 560,
+		absorbed: "green",
+		seen: "purple"
+	},
+	{
+		from: 560,
+		to: 580,
+		absorbed: "yellow-green",
+		seen: "violet"
+	},
+	{
+		from: 580,
+		to: 595,
+		absorbed: "yellow",
+		seen: "blue"
+	},
+	{
+		from: 595,
+		to: 650,
+		absorbed: "orange",
+		seen: "blue-green"
+	},
+	{
+		from: 650,
+		to: 750,
+		absorbed: "red",
+		seen: "green-blue"
+	}
+];
+/**
+* What colour a solution looks, given the wavelength it absorbs.
+*
+* The answer is the COMPLEMENTARY colour, never the absorbed one. Copper sulfate absorbs orange
+* light at about 600 nm and therefore looks blue, and a learner who says it looks blue because it
+* absorbs blue has the physics exactly backwards.
+*/
+function observedColour(wavelengthNm) {
+	const band = WHEEL.find((b) => wavelengthNm >= b.from && wavelengthNm < b.to);
+	if (!band) throw new Error(`${wavelengthNm} nm is outside the visible range (400-750 nm), so the complex would look colourless.`);
+	return {
+		absorbed: band.absorbed,
+		seen: band.seen,
+		wavelengthNm
+	};
+}
+
+//#endregion
+export { AVOGADRO, LIGANDS, LIGHT_SPEED, PLANCK, bondAngle, complexCharge, complexFormula, coordinationNumber, geometryOf, observedColour, splittingEnergy, splittingEnergyPerMole, stereoisomers, wavelengthFor };

package/dist/chem/cycle.d.mts

@@ -0,0 +1,75 @@
+import { Quantity } from "../quantity/index.mjs";
+import { Worked } from "../core/worked.mjs";
+
+//#region src/chem/cycle.d.ts
+/** kJ mol⁻¹ is what every data book and every mark scheme uses. */
+declare const DEFAULT_CYCLE_UNIT = "kJ/mol";
+interface CycleTerm {
+  /** "first ionisation energy of Na". Shown in the working. */
+  readonly label: string;
+  /** The enthalpy change for this step as written. Omit for the unknown. */
+  readonly value?: number | Quantity;
+  /** Stoichiometric multiplier, e.g. 2 chlorine atomisations in MgCl₂. Default 1. */
+  readonly per?: number;
+  /** The datum is quoted for the REVERSE of the step as written, so negate it. */
+  readonly reversed?: boolean;
+}
+interface CycleSpec {
+  readonly title?: string;
+  /** Unit for bare numbers. Default kJ/mol. */
+  readonly unit?: string;
+  /** The route: the steps that must sum to the total. */
+  readonly route: readonly CycleTerm[];
+  /** The overall change the route must add up to. */
+  readonly total: CycleTerm;
+}
+interface CycleSolution {
+  readonly label: string;
+  readonly value: number;
+  readonly unit: string;
+  readonly quantity: Quantity;
+  /** Negative is exothermic, by the convention above. */
+  readonly exothermic: boolean;
+  /** True when the solved term was the overall change rather than a step. */
+  readonly isTotal: boolean;
+}
+declare class Cycle {
+  readonly title: string;
+  readonly unit: string;
+  readonly route: readonly CycleTerm[];
+  readonly total: CycleTerm;
+  constructor(spec: CycleSpec);
+  /** The signed contribution of a term, in `this.unit`, with `per` and `reversed` applied. */
+  contribution(term: CycleTerm): number;
+  /** Sum of the steps that have values. */
+  private sumKnownSteps;
+  /**
+   * The one unknown term.
+   *
+   * If a step is unknown: step = total − (the other steps).
+   * If the total is unknown: total = the sum of the steps.
+   */
+  solve(): CycleSolution;
+  private report;
+  /**
+   * With every term known, how far the route misses the total by.
+   *
+   * Zero is a cycle that is self-consistent. This is the check worth running over an authored
+   * lesson: five data-book enthalpies and a quoted formation enthalpy that do NOT close to within a
+   * kilojoule mean one of the six numbers is wrong, and the lesson cannot say which.
+   */
+  residual(): number;
+  /** True when the cycle closes to within `tol` (default 1 kJ/mol, the data-book rounding). */
+  closes(tol?: number): boolean;
+  /**
+   * The working: every step with its sign, then the rearrangement and the answer.
+   *
+   * A `per` factor is shown as `2 × 122`, not as `244`, because the per-mole datum is the thing the
+   * mark scheme wants to see quoted.
+   */
+  steps(sf?: number): Worked;
+}
+/** `cycle({ route: [...], total: {...} })`. */
+declare const cycle: (spec: CycleSpec) => Cycle;
+//#endregion
+export { Cycle, CycleSolution, CycleSpec, CycleTerm, DEFAULT_CYCLE_UNIT, cycle };