@classytic/stage 0.3.0 → 0.4.0

package/dist/chem/hazard.mjs

@@ -0,0 +1,329 @@
+//#region src/chem/hazard.ts
+/**
+* Precautions that score nothing, because they are true of every experiment.
+*
+* Kept as a list rather than a judgement so that it can be tested against, and so a lesson gate can
+* one day refuse a hazard answer built only from these.
+*/
+const GENERIC = [
+	"wear safety goggles",
+	"wear goggles",
+	"wear eye protection",
+	"wear a lab coat",
+	"wear gloves",
+	"be careful",
+	"take care",
+	"wash your hands",
+	"tie back long hair"
+];
+/**
+* True when a precaution is one of the generic ones and would score nothing on its own.
+*
+* Note the "on its own": gloves are a real precaution when they follow from a named corrosive
+* substance, which is why the entries below that use them say what they are for.
+*/
+const isGenericPrecaution = (text) => {
+	const t = text.trim().toLowerCase().replace(/[.]$/, "");
+	return GENERIC.some((g) => t === g || t === `${g}.`);
+};
+/**
+* The reagents our chemistry labs actually put in a learner's hand.
+*
+* Added to when a lab needs one, never speculatively: an entry nobody reads is an entry nobody
+* checks.
+*/
+const REAGENTS = [
+	{
+		id: "ammonia-concentrated",
+		name: "concentrated aqueous ammonia",
+		formula: "NH3",
+		strength: "concentrated",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it burns skin and eyes on contact",
+			precaution: "wear gloves, and dilute any splash with plenty of cold water at once"
+		}, {
+			hazard: "harmful",
+			statement: "it gives off a pungent vapour that irritates the lungs",
+			precaution: "use it in a fume cupboard and keep the bottle stoppered between additions"
+		}]
+	},
+	{
+		id: "ammonia-dilute",
+		name: "dilute aqueous ammonia",
+		formula: "NH3",
+		strength: "dilute",
+		hazards: [{
+			hazard: "irritant",
+			statement: "it irritates skin and eyes, and its vapour irritates the lungs",
+			precaution: "keep the bottle stoppered and work in a ventilated room"
+		}]
+	},
+	{
+		id: "sulfuric-concentrated",
+		name: "concentrated sulfuric acid",
+		formula: "H2SO4",
+		strength: "concentrated",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it destroys skin and eyes, and it dehydrates paper and sugar on contact",
+			precaution: "wear gloves, and add the acid to water rather than water to the acid"
+		}]
+	},
+	{
+		id: "sulfuric-dilute",
+		name: "dilute sulfuric acid",
+		formula: "H2SO4",
+		strength: "dilute",
+		hazards: [{
+			hazard: "irritant",
+			statement: "it irritates skin and stings in a cut",
+			precaution: "rinse any splash off under the tap before continuing"
+		}]
+	},
+	{
+		id: "sodium-hydroxide",
+		name: "aqueous sodium hydroxide",
+		formula: "NaOH",
+		strength: "solution",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it attacks skin and is especially damaging to eyes, where it does not sting at first",
+			precaution: "wear gloves, and flood any eye splash with water for ten minutes"
+		}]
+	},
+	{
+		id: "manganate-vii",
+		name: "acidified potassium manganate(VII)",
+		formula: "KMnO4",
+		strength: "solution",
+		hazards: [{
+			hazard: "oxidising",
+			statement: "it reacts vigorously with anything that can be oxidised, including paper and skin",
+			precaution: "keep it away from the ethanol and the paper towels on the bench"
+		}, {
+			hazard: "harmful",
+			statement: "it stains skin brown and the stain is manganese(IV) oxide, not dye",
+			precaution: "fill the burette with a funnel rather than pouring from the bottle"
+		}]
+	},
+	{
+		id: "dichromate-vi",
+		name: "potassium dichromate(VI)",
+		formula: "K2Cr2O7",
+		strength: "solution",
+		hazards: [{
+			hazard: "carcinogenic",
+			statement: "chromium(VI) causes cancer and is absorbed through skin",
+			precaution: "handle it only as a made-up solution, wear gloves, and never weigh the solid out yourself"
+		}, {
+			hazard: "environmental",
+			statement: "it is toxic to aquatic life",
+			precaution: "pour the residues into the labelled chromium waste bottle, not down the sink"
+		}]
+	},
+	{
+		id: "nickel-salt",
+		name: "a soluble nickel(II) salt",
+		formula: "NiSO4",
+		strength: "solution",
+		hazards: [{
+			hazard: "carcinogenic",
+			statement: "nickel compounds are carcinogenic if their dust is breathed in",
+			precaution: "use the prepared solution and never grind or weigh the solid"
+		}, {
+			hazard: "harmful",
+			statement: "repeated skin contact causes a lasting nickel allergy",
+			precaution: "wear gloves, because the sensitisation does not wear off once it has started"
+		}]
+	},
+	{
+		id: "copper-salt",
+		name: "a soluble copper(II) salt",
+		formula: "CuSO4",
+		strength: "solution",
+		hazards: [{
+			hazard: "harmful",
+			statement: "it is harmful if swallowed",
+			precaution: "fill the pipette with a filler, never by mouth"
+		}, {
+			hazard: "environmental",
+			statement: "it is very toxic to aquatic life",
+			precaution: "pour the residues into the heavy-metal waste bottle, not down the sink"
+		}]
+	},
+	{
+		id: "barium-salt",
+		name: "a soluble barium salt",
+		formula: "BaCl2",
+		strength: "solution",
+		hazards: [{
+			hazard: "toxic",
+			statement: "soluble barium salts are poisonous if swallowed",
+			precaution: "fill the pipette with a filler, and wash hands before leaving the laboratory"
+		}]
+	},
+	{
+		id: "phenol",
+		name: "phenol solution",
+		formula: "C6H5OH",
+		strength: "solution",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it burns skin badly, and the burn is numb at first because phenol deadens the nerves",
+			precaution: "wear gloves, and wash any splash off immediately even if it does not hurt"
+		}, {
+			hazard: "toxic",
+			statement: "it is absorbed through unbroken skin and is poisonous that way",
+			precaution: "make up and run the solvent in a fume cupboard, and never handle it barehanded"
+		}]
+	},
+	{
+		id: "hydrochloric-concentrated",
+		name: "concentrated hydrochloric acid",
+		formula: "HCl",
+		strength: "concentrated",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it burns skin and gives off choking hydrogen chloride fumes",
+			precaution: "keep the bottle in the fume cupboard and carry the sample to it, not the reverse"
+		}]
+	},
+	{
+		id: "nitric-acid-dilute",
+		name: "dilute nitric acid",
+		formula: "HNO3",
+		strength: "dilute",
+		hazards: [{
+			hazard: "irritant",
+			statement: "it irritates skin and leaves a yellow stain where it touches",
+			precaution: "acidify with a teat pipette rather than pouring from the bottle"
+		}]
+	},
+	{
+		id: "limewater",
+		name: "limewater",
+		formula: "Ca(OH)2",
+		strength: "solution",
+		hazards: [{
+			hazard: "irritant",
+			statement: "it is alkaline and irritates the eyes",
+			precaution: "bubble the gas through it rather than shaking the tube, so it cannot splash up"
+		}]
+	},
+	{
+		id: "sulfur-dioxide",
+		name: "sulfur dioxide",
+		formula: "SO2",
+		strength: "gas",
+		hazards: [{
+			hazard: "toxic",
+			statement: "it is a choking gas that triggers asthma at very low concentrations",
+			precaution: "generate it in a fume cupboard and stopper the tube between tests"
+		}]
+	},
+	{
+		id: "silver-nitrate",
+		name: "aqueous silver nitrate",
+		formula: "AgNO3",
+		strength: "solution",
+		hazards: [{
+			hazard: "corrosive",
+			statement: "it burns skin and leaves a black stain that takes days to wear off",
+			precaution: "wear gloves, and add it dropwise from a teat pipette rather than pouring"
+		}]
+	},
+	{
+		id: "bromine",
+		name: "bromine",
+		formula: "Br2",
+		strength: "concentrated",
+		hazards: [{
+			hazard: "toxic",
+			statement: "its vapour is toxic and it causes deep burns that heal slowly",
+			precaution: "use it in a fume cupboard, as bromine water rather than the liquid"
+		}]
+	},
+	{
+		id: "chlorine",
+		name: "chlorine",
+		formula: "Cl2",
+		strength: "gas",
+		hazards: [{
+			hazard: "toxic",
+			statement: "it damages the lungs and is dense enough to collect in a sink",
+			precaution: "generate and use it in a fume cupboard with the sash low"
+		}]
+	},
+	{
+		id: "ethanol",
+		name: "ethanol",
+		formula: "C2H5OH",
+		strength: "concentrated",
+		hazards: [{
+			hazard: "flammable",
+			statement: "its vapour catches fire easily and the flame is almost invisible",
+			precaution: "heat it in a water bath and turn off every Bunsen burner in the room first"
+		}]
+	},
+	{
+		id: "potassium-cyanide",
+		name: "potassium cyanide",
+		formula: "KCN",
+		strength: "solution",
+		hazards: [{
+			hazard: "toxic",
+			statement: "it is acutely poisonous, and any acid added to it releases hydrogen cyanide gas",
+			precaution: "never let it meet an acid, and use it only in a fume cupboard"
+		}]
+	},
+	{
+		id: "hydrogen",
+		name: "hydrogen",
+		formula: "H2",
+		strength: "gas",
+		hazards: [{
+			hazard: "explosive",
+			statement: "it forms an explosive mixture with air over a wide range of compositions",
+			precaution: "let it flush the apparatus through before any flame is brought near"
+		}]
+	}
+];
+const reagentById = (id) => REAGENTS.find((r) => r.id === id);
+/** Every reagent carrying a given hazard class, for a lesson that groups by hazard. */
+const reagentsWith = (hazard) => REAGENTS.filter((r) => r.hazards.some((h) => h.hazard === hazard));
+/**
+* The creditable sentence: substance, hazard, precaution.
+*
+* Built rather than authored, so that every lab and every lesson states a hazard the same way and
+* a learner meets the same three-part shape every time. That repetition is the teaching: the shape
+* of the sentence is what the exam pays for.
+*/
+const hazardSentence = (reagent, hazard) => `${reagent.name} is ${hazard.hazard}: ${hazard.statement}, so ${hazard.precaution}.`;
+/** Every creditable sentence for a reagent. */
+const hazardSentences = (reagent) => reagent.hazards.map((h) => hazardSentence(reagent, h));
+/**
+* The single most serious hazard a reagent carries, for a one-line warning.
+*
+* Ordered by what would hurt a learner most, not alphabetically. A substance that is both an
+* irritant and a carcinogen must not be introduced as an irritant.
+*/
+const SEVERITY = [
+	"explosive",
+	"carcinogenic",
+	"toxic",
+	"corrosive",
+	"flammable",
+	"oxidising",
+	"harmful",
+	"irritant",
+	"environmental"
+];
+function worstHazard(reagent) {
+	const first = [...reagent.hazards].sort((a, b) => SEVERITY.indexOf(a.hazard) - SEVERITY.indexOf(b.hazard))[0];
+	if (!first) throw new Error(`${reagent.name} has no hazards declared.`);
+	return first;
+}
+
+//#endregion
+export { REAGENTS, hazardSentence, hazardSentences, isGenericPrecaution, reagentById, reagentsWith, worstHazard };

package/dist/chem/index.d.mts

@@ -1,8 +1,37 @@
+import { Cycle, CycleSolution, CycleSpec, CycleTerm, DEFAULT_CYCLE_UNIT, cycle } from "./cycle.mjs";
+import { HalfEquation, IonicEquation, Medium, Species, Term as Term$1, balanceHalf, combineHalves, halfToString, halfToUnicode, ionicToString, ionicToUnicode, oxidationChange, oxidationNumbers, parseSpecies, speciesToUnicode } from "./redox.mjs";
+import { AVOGADRO, ColourResult, ComplexSpec, Geometry, LIGANDS, LIGHT_SPEED, Ligand, PLANCK, StereoResult, bondAngle, complexCharge, complexFormula, coordinationNumber, geometryOf, observedColour, splittingEnergy, splittingEnergyPerMole, stereoisomers, wavelengthFor } from "./complex.mjs";
+import { Hazard, HazardClass, REAGENTS, Reagent, Strength, hazardSentence, hazardSentences, isGenericPrecaution, reagentById, reagentsWith, worstHazard } from "./hazard.mjs";
+import { GROUP_LABELS, GROUP_NODES, GroupNode, ROUTE_EDGES, Route, RouteEdge, allRoutes, chainChangingEdges, edgeBetween, edgesAlong, edgesFrom, findRoute, shortestSteps } from "./synthesis.mjs";
+import { MULTIPLICITY_NAMES, Multiplicity, NmrMolecule, NmrPeak, NmrSpectrum, ProtonEnvironment, SHIFT_RANGES, ShiftKey, ShiftRange, afterD2O, integrationRatio, linePositions, multiplicityOf, predictNmr, splittingPattern } from "./nmr.mjs";
+import { ATOMIC_MASS, Atom, Bond, Element, Structure, atomCounts, bondOrderSum, bondsAt, carbonCount, chargedValence, degreesOfUnsaturation, formatCounts, implicitHydrogens, molecularFormula, neighbours, otherEnd, parseSmiles, relativeMass, ringCount, totalCharge } from "./molecule.mjs";
+import { Backbone, backboneOf, longestChain, ringSystems } from "./skeleton.mjs";
+import { LaidOut, Point, freeDirection, freeDirections, layout, layoutOf, ringCentre } from "./layout.mjs";
+import { FoundGroup, GroupKind, functionalGroups, groupKinds, hasGroup } from "./functional-groups.mjs";
+import { LinkKind, PolymerKind, RepeatUnit, addition, canSustainChain, chainMass, condensation, unitsInChain } from "./polymer.mjs";
+import { Component, Identification, identify, resolvedBy, retentionFactor, spotDistance, unresolvedPairs } from "./chromatography.mjs";
+import { ElementCount, MassFraction, empiricalFormula, formatFormula, molarMass, molecularFormulaFor, parseFormula, percentComposition, unitsInMolecule } from "./formula.mjs";
+import { Bonded, Centre, CentreOptions, formatCentre, parseCentre, readFormula } from "./species.mjs";
+import { BalancedEquation, Term, atomTally, balance, chargeTally, formatEquation, splitEquation } from "./equation.mjs";
+import { DoubleBondShape, DoubleBondStereo, RankedSubstituent, Stereocentre, StereoisomerCount, compareBranches, comparePriority, maximumStereoisomers, rankSubstituents, stereocentres, stereogenicDoubleBonds, stereoisomerCount } from "./stereo.mjs";
+import { PrecipitationCheck, PrecipitationVerdict, SOLUBILITY_PRODUCTS, SaltFormula, SparinglySoluble, ionicProduct, kspComparisonMisleads, kspFromSolubility, moreSoluble, saltByFormula, solubilityFromKsp, solubilityWithCommonIon, willPrecipitate } from "./solution.mjs";
+import { ANIONS, CATIONS, IONS, Ion, IonicCompound, assessCounts, compoundOf, ionByName, ionicCompound, neutralRatio, writeIon } from "./ionic.mjs";
+import { CONSTANTS, DERIVATIONS, absorbanceFromIntensity, beerLambert, combinedGasLaw, concentration, density, dilution, heatEnergy, idealGas, kelvinFrom, massForSolution, molality, molesFromGasVolume, molesFromMass, molesFromParticles, molesFromSolution } from "./relations.mjs";
+import { Amount, ProductState, ReactantState, Reaction, YieldReport, amountNeeded, apparentYield, molesOf, percentageYield, react, theoreticalYield } from "./stoichiometry.mjs";
+import { DiatomicResult, Level, Magnetism, MolecularOrbital, S_P_MIXING_NOTE, diatomic, fillOrbitals, formatOccupancy, orbitalSequence } from "./molecular-orbital.mjs";
+import { LewisCount, OctetStatus, lewisCount, octetStatus, valenceElectronsFor } from "./lewis.mjs";
+import { Vec3 } from "../core/vec3.mjs";
+import { ElectronGeometry, MolecularShape, OBSERVED_ANGLES, Region, angleBetween, directionsFor, placeLonePairs, shapeOf } from "./vsepr.mjs";
+
 //#region src/chem/index.d.ts
 /**
- * `chem`, acid–base / pH AND electrochemistry / Nernst, as a PURE kernel (no
- * React, no pixels). The engine behind titration curves, pH problems, and galvanic
- * cells.
+ * `chem`, acid–base / pH and chemical kinetics, as a PURE kernel (no React, no
+ * pixels). The engine behind titration curves, pH problems and rate laws.
+ *
+ * This header used to claim electrochemistry as well, and for a while that was one
+ * function taking standard electrode potentials it did not hold. Electrochemistry
+ * is now its own subpath, `@classytic/stage/electro`, with the series, electrolysis,
+ * Faraday's laws and conductivity in it.
  *
  * pH at any point is found by solving the exact charge balance for [H⁺] = h:
  *
@@ -48,37 +77,9 @@ interface TitrationCurve {
 /** Sample the full titration curve from 0 to `span`·vEq (default 2×). */
 declare function titrationCurve(spec: TitrationSpec, n?: number, span?: number): TitrationCurve;
 /** Universal gas constant, J/(mol·K). */
-declare const R = 8.314462618;
-/** Faraday constant, C/mol. */
-declare const F = 96485.332;
+declare const R: number;
 /** Standard temperature, K (25 °C). */
 declare const T_STD = 298.15;
-interface HalfCell {
-  /** Electrode metal symbol (e.g. 'Zn'). */
-  metal: string;
-  /** Ion charge z in Mᶻ⁺ (e.g. 2 for Zn²⁺). */
-  z: number;
-  /** Standard reduction potential E°, volts. */
-  E0: number;
-  /** Ion concentration [Mᶻ⁺], mol/L. */
-  conc: number;
-}
-interface CellResult {
-  cathode: HalfCell;
-  anode: HalfCell;
-  /** Standard cell potential E°cell = E°cathode − E°anode, V. */
-  E0cell: number;
-  /** Electrons transferred (balances the half-reactions). */
-  n: number;
-  /** Reaction quotient Q = [anode ion]^(n/zₐ) / [cathode ion]^(n/z_c). */
-  Q: number;
-  /** Actual cell potential from the Nernst equation, V. */
-  E: number;
-  /** Does the cell drive current as written (E > 0)? */
-  spontaneous: boolean;
-}
-/** Galvanic cell from two half-cells; cathode/anode assigned by standard potential. */
-declare function galvanicCell(x: HalfCell, y: HalfCell, T?: number): CellResult;
 /** Arrhenius rate constant k = A·e^(−Ea/RT). */
 declare function arrhenius(A: number, Ea: number, T: number): number;
 /** Ratio k(T)/k(Tref) at fixed Ea, the stable way to scale a rate without a raw A. */
@@ -115,4 +116,4 @@ interface StoichResult {
 /** Solve a balanced reaction for the limiting reagent, extent, products and leftovers. */
 declare function solveStoichiometry(reactants: StoichSpecies[], products: StoichSpecies[], amountsMol: number[]): StoichResult;
 //#endregion
-export { Analyte, CellResult, F, HalfCell, Kw, R, RateOrder, StoichResult, StoichSpecies, T_STD, TitrationCurve, TitrationSpec, arrhenius, arrheniusRatio, concAt, fractionAboveEa, galvanicCell, halfLife, pHAt, solveStoichiometry, titrationCurve };
+export { ANIONS, ATOMIC_MASS, AVOGADRO, type Amount, Analyte, type Atom, type Backbone, type BalancedEquation, type Bond, type Bonded, CATIONS, CONSTANTS, type Centre, type CentreOptions, type ColourResult, type ComplexSpec, type Component, Cycle, type CycleSolution, type CycleSpec, type CycleTerm, DEFAULT_CYCLE_UNIT, DERIVATIONS, type DiatomicResult, type DoubleBondShape, type DoubleBondStereo, type ElectronGeometry, type Element, type ElementCount, type Term as EquationTerm, type FoundGroup, GROUP_LABELS, GROUP_NODES, type Geometry, type GroupKind, type GroupNode, type HalfEquation, type Hazard, type HazardClass, IONS, type Identification, type Ion, type IonicCompound, type IonicEquation, Kw, LIGANDS, LIGHT_SPEED, type LaidOut, type Level, type LewisCount, type Ligand, type LinkKind, MULTIPLICITY_NAMES, type Magnetism, type MassFraction, type Medium, type MolecularOrbital, type MolecularShape, type Multiplicity, type NmrMolecule, type NmrPeak, type NmrSpectrum, OBSERVED_ANGLES, type OctetStatus, PLANCK, type Point, type PolymerKind, type PrecipitationCheck, type PrecipitationVerdict, type ProductState, type ProtonEnvironment, R, REAGENTS, ROUTE_EDGES, type RankedSubstituent, RateOrder, type ReactantState, type Reaction, type Reagent, type Region, type RepeatUnit, type Route, type RouteEdge, SHIFT_RANGES, SOLUBILITY_PRODUCTS, S_P_MIXING_NOTE, type SaltFormula, type ShiftKey, type ShiftRange, type SparinglySoluble, type Species, type StereoResult, type Stereocentre, type StereoisomerCount, StoichResult, StoichSpecies, type Strength, type Structure, T_STD, type Term$1 as Term, TitrationCurve, TitrationSpec, type Vec3, type YieldReport, absorbanceFromIntensity, addition, afterD2O, allRoutes, amountNeeded, angleBetween, apparentYield, arrhenius, arrheniusRatio, assessCounts, atomCounts, atomTally, backboneOf, balance, balanceHalf, beerLambert, bondAngle, bondOrderSum, bondsAt, canSustainChain, carbonCount, chainChangingEdges, chainMass, chargeTally, chargedValence, combineHalves, combinedGasLaw, compareBranches, comparePriority, complexCharge, complexFormula, compoundOf, concAt, concentration, condensation, coordinationNumber, cycle, degreesOfUnsaturation, density, diatomic, dilution, directionsFor, edgeBetween, edgesAlong, edgesFrom, empiricalFormula, fillOrbitals, findRoute, formatCentre, formatCounts, formatEquation, formatFormula, formatOccupancy, fractionAboveEa, freeDirection, freeDirections, functionalGroups, geometryOf, groupKinds, halfLife, halfToString, halfToUnicode, hasGroup, hazardSentence, hazardSentences, heatEnergy, idealGas, identify, implicitHydrogens, integrationRatio, ionByName, ionicCompound, ionicProduct, ionicToString, ionicToUnicode, isGenericPrecaution, kelvinFrom, kspComparisonMisleads, kspFromSolubility, layout, layoutOf, lewisCount, linePositions, longestChain, massForSolution, maximumStereoisomers, molality, molarMass, molecularFormula, molecularFormulaFor, molesFromGasVolume, molesFromMass, molesFromParticles, molesFromSolution, molesOf, moreSoluble, multiplicityOf, neighbours, neutralRatio, observedColour, octetStatus, orbitalSequence, otherEnd, oxidationChange, oxidationNumbers, pHAt, parseCentre, parseFormula, parseSmiles, parseSpecies, percentComposition, percentageYield, placeLonePairs, predictNmr, rankSubstituents, react, readFormula, reagentById, reagentsWith, relativeMass, resolvedBy, retentionFactor, ringCentre, ringCount, ringSystems, saltByFormula, shapeOf, shortestSteps, solubilityFromKsp, solubilityWithCommonIon, solveStoichiometry, speciesToUnicode, splitEquation, splittingEnergy, splittingEnergyPerMole, splittingPattern, spotDistance, stereocentres, stereogenicDoubleBonds, stereoisomerCount, stereoisomers, theoreticalYield, titrationCurve, totalCharge, unitsInChain, unitsInMolecule, unresolvedPairs, valenceElectronsFor, wavelengthFor, willPrecipitate, worstHazard, writeIon };

package/dist/chem/index.mjs

@@ -1,8 +1,37 @@
+import { GAS_CONSTANT } from "../core/constants.mjs";
+import { Cycle, DEFAULT_CYCLE_UNIT, cycle } from "./cycle.mjs";
+import { balanceHalf, combineHalves, halfToString, halfToUnicode, ionicToString, ionicToUnicode, oxidationChange, oxidationNumbers, parseSpecies, speciesToUnicode } from "./redox.mjs";
+import { AVOGADRO, LIGANDS, LIGHT_SPEED, PLANCK, bondAngle, complexCharge, complexFormula, coordinationNumber, geometryOf, observedColour, splittingEnergy, splittingEnergyPerMole, stereoisomers, wavelengthFor } from "./complex.mjs";
+import { REAGENTS, hazardSentence, hazardSentences, isGenericPrecaution, reagentById, reagentsWith, worstHazard } from "./hazard.mjs";
+import { GROUP_LABELS, GROUP_NODES, ROUTE_EDGES, allRoutes, chainChangingEdges, edgeBetween, edgesAlong, edgesFrom, findRoute, shortestSteps } from "./synthesis.mjs";
+import { MULTIPLICITY_NAMES, SHIFT_RANGES, afterD2O, integrationRatio, linePositions, multiplicityOf, predictNmr, splittingPattern } from "./nmr.mjs";
+import { ATOMIC_MASS, atomCounts, bondOrderSum, bondsAt, carbonCount, chargedValence, degreesOfUnsaturation, formatCounts, implicitHydrogens, molecularFormula, neighbours, otherEnd, parseSmiles, relativeMass, ringCount, totalCharge } from "./molecule.mjs";
+import { backboneOf, longestChain, ringSystems } from "./skeleton.mjs";
+import { freeDirection, freeDirections, layout, layoutOf, ringCentre } from "./layout.mjs";
+import { functionalGroups, groupKinds, hasGroup } from "./functional-groups.mjs";
+import { addition, canSustainChain, chainMass, condensation, unitsInChain } from "./polymer.mjs";
+import { identify, resolvedBy, retentionFactor, spotDistance, unresolvedPairs } from "./chromatography.mjs";
+import { empiricalFormula, formatFormula, molarMass, molecularFormulaFor, parseFormula, percentComposition, unitsInMolecule } from "./formula.mjs";
+import { formatCentre, parseCentre, readFormula } from "./species.mjs";
+import { atomTally, balance, chargeTally, formatEquation, splitEquation } from "./equation.mjs";
+import { compareBranches, comparePriority, maximumStereoisomers, rankSubstituents, stereocentres, stereogenicDoubleBonds, stereoisomerCount } from "./stereo.mjs";
+import { SOLUBILITY_PRODUCTS, ionicProduct, kspComparisonMisleads, kspFromSolubility, moreSoluble, saltByFormula, solubilityFromKsp, solubilityWithCommonIon, willPrecipitate } from "./solution.mjs";
+import { ANIONS, CATIONS, IONS, assessCounts, compoundOf, ionByName, ionicCompound, neutralRatio, writeIon } from "./ionic.mjs";
+import { CONSTANTS, DERIVATIONS, absorbanceFromIntensity, beerLambert, combinedGasLaw, concentration, density, dilution, heatEnergy, idealGas, kelvinFrom, massForSolution, molality, molesFromGasVolume, molesFromMass, molesFromParticles, molesFromSolution } from "./relations.mjs";
+import { amountNeeded, apparentYield, molesOf, percentageYield, react, theoreticalYield } from "./stoichiometry.mjs";
+import { lewisCount, octetStatus, valenceElectronsFor } from "./lewis.mjs";
+import { S_P_MIXING_NOTE, diatomic, fillOrbitals, formatOccupancy, orbitalSequence } from "./molecular-orbital.mjs";
+import { OBSERVED_ANGLES, angleBetween, directionsFor, placeLonePairs, shapeOf } from "./vsepr.mjs";
+
 //#region src/chem/index.ts
 /**
-* `chem`, acid–base / pH AND electrochemistry / Nernst, as a PURE kernel (no
-* React, no pixels). The engine behind titration curves, pH problems, and galvanic
-* cells.
+* `chem`, acid–base / pH and chemical kinetics, as a PURE kernel (no React, no
+* pixels). The engine behind titration curves, pH problems and rate laws.
+*
+* This header used to claim electrochemistry as well, and for a while that was one
+* function taking standard electrode potentials it did not hold. Electrochemistry
+* is now its own subpath, `@classytic/stage/electro`, with the series, electrolysis,
+* Faraday's laws and conductivity in it.
 *
 * pH at any point is found by solving the exact charge balance for [H⁺] = h:
 *
@@ -60,32 +89,9 @@ function titrationCurve(spec, n = 160, span = 2) {
 	};
 }
 /** Universal gas constant, J/(mol·K). */
-const R = 8.314462618;
-/** Faraday constant, C/mol. */
-const F = 96485.332;
+const R = GAS_CONSTANT;
 /** Standard temperature, K (25 °C). */
 const T_STD = 298.15;
-const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-const lcm = (a, b) => a * b / gcd(a, b);
-/** Galvanic cell from two half-cells; cathode/anode assigned by standard potential. */
-function galvanicCell(x, y, T = T_STD) {
-	const xIsCathode = x.E0 > y.E0 || x.E0 === y.E0 && x.conc >= y.conc;
-	const cathode = xIsCathode ? x : y;
-	const anode = xIsCathode ? y : x;
-	const E0cell = cathode.E0 - anode.E0;
-	const n = lcm(anode.z, cathode.z);
-	const Q = Math.pow(anode.conc, n / anode.z) / Math.pow(cathode.conc, n / cathode.z);
-	const E = E0cell - R * T / (n * F) * Math.log(Q);
-	return {
-		cathode,
-		anode,
-		E0cell,
-		n,
-		Q,
-		E,
-		spontaneous: E > 0
-	};
-}
 /** Arrhenius rate constant k = A·e^(−Ea/RT). */
 function arrhenius(A, Ea, T) {
 	return A * Math.exp(-Ea / (R * T));
@@ -128,4 +134,4 @@ function solveStoichiometry(reactants, products, amountsMol) {
 }
 
 //#endregion
-export { F, Kw, R, T_STD, arrhenius, arrheniusRatio, concAt, fractionAboveEa, galvanicCell, halfLife, pHAt, solveStoichiometry, titrationCurve };
+export { ANIONS, ATOMIC_MASS, AVOGADRO, CATIONS, CONSTANTS, Cycle, DEFAULT_CYCLE_UNIT, DERIVATIONS, GROUP_LABELS, GROUP_NODES, IONS, Kw, LIGANDS, LIGHT_SPEED, MULTIPLICITY_NAMES, OBSERVED_ANGLES, PLANCK, R, REAGENTS, ROUTE_EDGES, SHIFT_RANGES, SOLUBILITY_PRODUCTS, S_P_MIXING_NOTE, T_STD, absorbanceFromIntensity, addition, afterD2O, allRoutes, amountNeeded, angleBetween, apparentYield, arrhenius, arrheniusRatio, assessCounts, atomCounts, atomTally, backboneOf, balance, balanceHalf, beerLambert, bondAngle, bondOrderSum, bondsAt, canSustainChain, carbonCount, chainChangingEdges, chainMass, chargeTally, chargedValence, combineHalves, combinedGasLaw, compareBranches, comparePriority, complexCharge, complexFormula, compoundOf, concAt, concentration, condensation, coordinationNumber, cycle, degreesOfUnsaturation, density, diatomic, dilution, directionsFor, edgeBetween, edgesAlong, edgesFrom, empiricalFormula, fillOrbitals, findRoute, formatCentre, formatCounts, formatEquation, formatFormula, formatOccupancy, fractionAboveEa, freeDirection, freeDirections, functionalGroups, geometryOf, groupKinds, halfLife, halfToString, halfToUnicode, hasGroup, hazardSentence, hazardSentences, heatEnergy, idealGas, identify, implicitHydrogens, integrationRatio, ionByName, ionicCompound, ionicProduct, ionicToString, ionicToUnicode, isGenericPrecaution, kelvinFrom, kspComparisonMisleads, kspFromSolubility, layout, layoutOf, lewisCount, linePositions, longestChain, massForSolution, maximumStereoisomers, molality, molarMass, molecularFormula, molecularFormulaFor, molesFromGasVolume, molesFromMass, molesFromParticles, molesFromSolution, molesOf, moreSoluble, multiplicityOf, neighbours, neutralRatio, observedColour, octetStatus, orbitalSequence, otherEnd, oxidationChange, oxidationNumbers, pHAt, parseCentre, parseFormula, parseSmiles, parseSpecies, percentComposition, percentageYield, placeLonePairs, predictNmr, rankSubstituents, react, readFormula, reagentById, reagentsWith, relativeMass, resolvedBy, retentionFactor, ringCentre, ringCount, ringSystems, saltByFormula, shapeOf, shortestSteps, solubilityFromKsp, solubilityWithCommonIon, solveStoichiometry, speciesToUnicode, splitEquation, splittingEnergy, splittingEnergyPerMole, splittingPattern, spotDistance, stereocentres, stereogenicDoubleBonds, stereoisomerCount, stereoisomers, theoreticalYield, titrationCurve, totalCharge, unitsInChain, unitsInMolecule, unresolvedPairs, valenceElectronsFor, wavelengthFor, willPrecipitate, worstHazard, writeIon };

package/dist/chem/ionic.d.mts

@@ -0,0 +1,98 @@
+//#region src/chem/ionic.d.ts
+/**
+ * Ions, and the formula two of them make.
+ *
+ * ## The one rule, which is usually taught as a trick
+ *
+ * "Write the formula of aluminium oxide" is answered in most classrooms by the crossover trick:
+ * write the charges, swap them over, drop the signs. It gives Al2O3, and it gives the wrong answer
+ * for magnesium oxide, where crossing over 2 and 2 gives Mg2O2 and the compound is MgO. The trick
+ * then acquires a patch: "and cancel down if you can".
+ *
+ * There is no trick. A compound has no overall charge, so the positive and negative charges in it
+ * must cancel exactly, and the formula is the SMALLEST whole number of each ion that makes them.
+ * That is a lowest common multiple, and it gets magnesium oxide right without a patch because the
+ * smallest multiple of 2 that is also a multiple of 2 is 2, not 4.
+ *
+ * {@link neutralRatio} computes it that way, so the reasoning a learner is shown is the reasoning
+ * the engine uses.
+ *
+ * ## Charges are data, and the ones worth knowing are here
+ *
+ * Which charge an ion carries is not derivable for a transition metal, and only roughly derivable
+ * from the group for everything else. So the common ones are listed, with their names, because
+ * "what is the formula of iron(III) sulfate" needs both the charge and the fact that sulfate is one
+ * unit that keeps its brackets.
+ *
+ * Pure: no React, no pixels.
+ */
+interface Ion {
+  /** As written in a formula, without the charge: "SO4", "Al", "NH4". */
+  readonly formula: string;
+  /** Signed: +3 for aluminium, -2 for sulfate. */
+  readonly charge: number;
+  /** The name it takes in a compound: "aluminium", "sulfate". */
+  readonly name: string;
+  /**
+   * Whether it is more than one atom, and so needs brackets when there is more than one of it.
+   *
+   * Ca(NO3)2 needs them and CaCl2 does not, and the difference is exactly this. Without brackets
+   * the formula reads as one nitrogen and thirty-two oxygens.
+   */
+  readonly polyatomic: boolean;
+}
+/** The cations a syllabus expects to be known. */
+declare const CATIONS: readonly Ion[];
+/** The anions a syllabus expects to be known. */
+declare const ANIONS: readonly Ion[];
+/** Every ion listed here, cations and anions together. */
+declare const IONS: readonly Ion[];
+/**
+ * Find an ion by the name it takes in a compound.
+ *
+ * Matched case-insensitively on BOTH sides. Lowercasing only the input looked right and failed for
+ * every ion whose name carries a Roman numeral, since "iron(iii)" never matches "iron(III)".
+ */
+declare const ionByName: (name: string) => Ion | undefined;
+/**
+ * How many of each ion make a compound with no overall charge, in the smallest whole numbers.
+ *
+ * The lowest common multiple of the two charge sizes, divided by each. Magnesium and oxide both
+ * carry two, their lowest common multiple is two, and one of each is the answer: MgO. The crossover
+ * trick would have given Mg2O2 and needed a separate rule to cancel it down.
+ */
+declare function neutralRatio(cationCharge: number, anionCharge: number): [number, number];
+/** One ion written out with its count, bracketed when it needs to be. */
+declare function writeIon(part: Ion, count: number): string;
+interface IonicCompound {
+  readonly formula: string;
+  readonly name: string;
+  readonly cation: Ion;
+  readonly anion: Ion;
+  readonly cationCount: number;
+  readonly anionCount: number;
+}
+/**
+ * The compound two ions form.
+ *
+ * `ionicFormula(aluminium, oxide)` gives Al2O3; `ionicFormula(magnesium, oxide)` gives MgO, not
+ * Mg2O2; `ionicFormula(calcium, nitrate)` gives Ca(NO3)2 with the brackets that stop it being read
+ * as thirty-two oxygens.
+ */
+declare function ionicCompound(cation: Ion, anion: Ion): IonicCompound;
+/** The same, by name: `compoundOf('calcium', 'carbonate')`. */
+declare function compoundOf(cationName: string, anionName: string): IonicCompound;
+/**
+ * Whether a proposed pair of counts makes a neutral compound, and whether it is the simplest one.
+ *
+ * Both answers matter and they are different. Mg2O2 IS neutral and is not a formula anyone writes,
+ * so a learner offering it has understood the charge balance and not the "smallest" part, and
+ * telling them only that it is wrong would hide which half they have.
+ */
+declare function assessCounts(cation: Ion, anion: Ion, cationCount: number, anionCount: number): {
+  totalCharge: number;
+  neutral: boolean;
+  simplest: boolean;
+};
+//#endregion
+export { ANIONS, CATIONS, IONS, Ion, IonicCompound, assessCounts, compoundOf, ionByName, ionicCompound, neutralRatio, writeIon };