@classytic/stage 0.2.0 → 0.4.0

package/dist/electro/electrolysis.d.mts

@@ -0,0 +1,96 @@
+//#region src/electro/electrolysis.d.ts
+/**
+ * Electrolysis: deciding what comes off each electrode, rather than remembering it.
+ *
+ * ## Why this is a decision and not a table
+ *
+ * The usual way this is taught is a table of electrolytes with their products written beside them,
+ * and it fails the first time a learner is asked about a solution that is not in the table. The
+ * worst case is the one most examined: CONCENTRATED sodium chloride gives chlorine at the anode
+ * and DILUTE sodium chloride gives oxygen, from the same two ions in the same solution. A table
+ * with one row for "NaCl(aq)" cannot express that, and a learner holding one will get it wrong.
+ *
+ * So nothing here stores a product. Three competitions are resolved:
+ *
+ *   1. At the cathode, which cation is reduced: the one lower in the reactivity series, meaning
+ *      the higher standard potential. Water, supplying H⁺, is always a candidate in solution, so a
+ *      metal more reactive than hydrogen never plates out of an aqueous solution.
+ *   2. At the anode, which anion is oxidised. Oxoanions such as sulfate and nitrate are never
+ *      discharged: their central atom is already fully oxidised, so OH⁻ from the water goes
+ *      instead and oxygen comes off. A halide competes with OH⁻ and wins when concentrated.
+ *   3. Whether the anode is inert at all. A copper anode in copper sulfate dissolves rather than
+ *      releasing oxygen, because oxidising the electrode itself is easier than oxidising anything
+ *      in the solution. That is not a special case to memorise, it is the same "easiest oxidation
+ *      wins" rule with one more candidate.
+ *
+ * ## Concentration, and being honest about a rule of thumb
+ *
+ * Whether chloride beats hydroxide is not decided by standard potentials: on those alone, OH⁻
+ * (+0.40 V) should always win over Cl⁻ (+1.36 V), and in concentrated brine it plainly does not.
+ * The real reasons are the overpotential for oxygen on most anode materials and the concentration
+ * term, and neither is examined at this level. The threshold used here is the teaching rule, and
+ * it is labelled as one rather than dressed up as a computed result.
+ *
+ * Pure: no React, no pixels.
+ */
+/** How the electrolyte is presented to the cell. */
+type Phase = 'molten' | 'aqueous';
+/** What the electrodes are made of. */
+type ElectrodeMaterial = 'inert' | 'copper' | 'silver' | 'nickel';
+interface Electrolyte {
+  readonly formula: string;
+  readonly cation: string;
+  readonly anion: string;
+  /** The couple that would reduce this cation. */
+  readonly cationCouple: string;
+  /** The couple that would oxidise this anion, or undefined for an oxoanion that never is. */
+  readonly anionCouple?: string;
+}
+/**
+ * The electrolytes a syllabus actually asks about.
+ *
+ * This IS a table, and it is a table of what is dissolved rather than of what comes out. The
+ * distinction is the whole point: composition is a fact about the beaker, products are a
+ * consequence to be worked out.
+ */
+declare const ELECTROLYTES: readonly Electrolyte[];
+declare const electrolyteByFormula: (formula: string) => Electrolyte | undefined;
+/**
+ * Above this concentration a halide is discharged in preference to hydroxide.
+ *
+ * A teaching threshold, not a measured boundary. See the note at the top of this file: the real
+ * crossover depends on the anode material's oxygen overpotential and moves with it. Half a mole
+ * per cubic decimetre sits between the "dilute" and "concentrated" of every question that asks.
+ */
+declare const HALIDE_DISCHARGE_THRESHOLD = 0.5;
+interface Discharge {
+  /** The species that reacts at this electrode. */
+  readonly species: string;
+  /** What comes off, or what happens to the electrode. */
+  readonly product: string;
+  /** The half-equation, written in the direction it runs. */
+  readonly equation: string;
+  /** Electrons per formula unit of product. */
+  readonly electrons: number;
+  /** Why this one and not the alternative. */
+  readonly because: string;
+  /** The alternative that lost, where there was one. */
+  readonly insteadOf?: string;
+}
+interface ElectrolysisConditions {
+  readonly electrolyte: Electrolyte;
+  readonly phase: Phase;
+  /** Concentration in mol/dm³. Ignored when molten. */
+  readonly concentration?: number;
+  readonly anodeMaterial?: ElectrodeMaterial;
+}
+interface ElectrolysisResult {
+  readonly cathode: Discharge;
+  readonly anode: Discharge;
+  /** What happens to the solution while it runs. */
+  readonly solution: string;
+}
+/** Run the three competitions and report what each electrode does. */
+declare function electrolyse(conditions: ElectrolysisConditions): ElectrolysisResult;
+//#endregion
+export { Discharge, ELECTROLYTES, ElectrodeMaterial, ElectrolysisConditions, ElectrolysisResult, Electrolyte, HALIDE_DISCHARGE_THRESHOLD, Phase, electrolyse, electrolyteByFormula };

package/dist/electro/electrolysis.mjs

@@ -0,0 +1,274 @@
+import { coupleById, oxidationEquation, reductionEquation } from "./couples.mjs";
+
+//#region src/electro/electrolysis.ts
+/**
+* Electrolysis: deciding what comes off each electrode, rather than remembering it.
+*
+* ## Why this is a decision and not a table
+*
+* The usual way this is taught is a table of electrolytes with their products written beside them,
+* and it fails the first time a learner is asked about a solution that is not in the table. The
+* worst case is the one most examined: CONCENTRATED sodium chloride gives chlorine at the anode
+* and DILUTE sodium chloride gives oxygen, from the same two ions in the same solution. A table
+* with one row for "NaCl(aq)" cannot express that, and a learner holding one will get it wrong.
+*
+* So nothing here stores a product. Three competitions are resolved:
+*
+*   1. At the cathode, which cation is reduced: the one lower in the reactivity series, meaning
+*      the higher standard potential. Water, supplying H⁺, is always a candidate in solution, so a
+*      metal more reactive than hydrogen never plates out of an aqueous solution.
+*   2. At the anode, which anion is oxidised. Oxoanions such as sulfate and nitrate are never
+*      discharged: their central atom is already fully oxidised, so OH⁻ from the water goes
+*      instead and oxygen comes off. A halide competes with OH⁻ and wins when concentrated.
+*   3. Whether the anode is inert at all. A copper anode in copper sulfate dissolves rather than
+*      releasing oxygen, because oxidising the electrode itself is easier than oxidising anything
+*      in the solution. That is not a special case to memorise, it is the same "easiest oxidation
+*      wins" rule with one more candidate.
+*
+* ## Concentration, and being honest about a rule of thumb
+*
+* Whether chloride beats hydroxide is not decided by standard potentials: on those alone, OH⁻
+* (+0.40 V) should always win over Cl⁻ (+1.36 V), and in concentrated brine it plainly does not.
+* The real reasons are the overpotential for oxygen on most anode materials and the concentration
+* term, and neither is examined at this level. The threshold used here is the teaching rule, and
+* it is labelled as one rather than dressed up as a computed result.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* The symbol and ion an active electrode dissolves to.
+*
+* A capitalised material name is NOT a chemical symbol, and treating it as one produced
+* "Copper²⁺" in a half-equation. Silver would have been worse: it dissolves to Ag⁺, one electron,
+* not the two every other entry here takes, so a rule that guessed the charge from the shape of
+* the word would have been wrong about the arithmetic and not just the spelling.
+*/
+const ACTIVE_ELECTRODE = {
+	copper: {
+		symbol: "Cu",
+		ion: "Cu²⁺",
+		electrons: 2
+	},
+	silver: {
+		symbol: "Ag",
+		ion: "Ag⁺",
+		electrons: 1
+	},
+	nickel: {
+		symbol: "Ni",
+		ion: "Ni²⁺",
+		electrons: 2
+	}
+};
+/**
+* The electrolytes a syllabus actually asks about.
+*
+* This IS a table, and it is a table of what is dissolved rather than of what comes out. The
+* distinction is the whole point: composition is a fact about the beaker, products are a
+* consequence to be worked out.
+*/
+const ELECTROLYTES = [
+	{
+		formula: "NaCl",
+		cation: "Na⁺",
+		anion: "Cl⁻",
+		cationCouple: "Na+/Na",
+		anionCouple: "Cl2/Cl-"
+	},
+	{
+		formula: "PbCl2",
+		cation: "Pb²⁺",
+		anion: "Cl⁻",
+		cationCouple: "Pb2+/Pb",
+		anionCouple: "Cl2/Cl-"
+	},
+	{
+		formula: "PbBr2",
+		cation: "Pb²⁺",
+		anion: "Br⁻",
+		cationCouple: "Pb2+/Pb",
+		anionCouple: "Br2/Br-"
+	},
+	{
+		formula: "KI",
+		cation: "K⁺",
+		anion: "I⁻",
+		cationCouple: "K+/K",
+		anionCouple: "I2/I-"
+	},
+	{
+		formula: "MgBr2",
+		cation: "Mg²⁺",
+		anion: "Br⁻",
+		cationCouple: "Mg2+/Mg",
+		anionCouple: "Br2/Br-"
+	},
+	{
+		formula: "CuSO4",
+		cation: "Cu²⁺",
+		anion: "SO₄²⁻",
+		cationCouple: "Cu2+/Cu"
+	},
+	{
+		formula: "H2SO4",
+		cation: "H⁺",
+		anion: "SO₄²⁻",
+		cationCouple: "H+/H2"
+	},
+	{
+		formula: "KNO3",
+		cation: "K⁺",
+		anion: "NO₃⁻",
+		cationCouple: "K+/K"
+	},
+	{
+		formula: "NaOH",
+		cation: "Na⁺",
+		anion: "OH⁻",
+		cationCouple: "Na+/Na"
+	},
+	{
+		formula: "AgNO3",
+		cation: "Ag⁺",
+		anion: "NO₃⁻",
+		cationCouple: "Ag+/Ag"
+	},
+	{
+		formula: "CuCl2",
+		cation: "Cu²⁺",
+		anion: "Cl⁻",
+		cationCouple: "Cu2+/Cu",
+		anionCouple: "Cl2/Cl-"
+	}
+];
+const electrolyteByFormula = (formula) => ELECTROLYTES.find((e) => e.formula.toLowerCase() === formula.toLowerCase());
+/**
+* Above this concentration a halide is discharged in preference to hydroxide.
+*
+* A teaching threshold, not a measured boundary. See the note at the top of this file: the real
+* crossover depends on the anode material's oxygen overpotential and moves with it. Half a mole
+* per cubic decimetre sits between the "dilute" and "concentrated" of every question that asks.
+*/
+const HALIDE_DISCHARGE_THRESHOLD = .5;
+const half = (couple, direction) => direction === "reduce" ? reductionEquation(couple) : oxidationEquation(couple);
+/** The couple for hydrogen, which is always a candidate in water. */
+const HYDROGEN = coupleById("H+/H2");
+/** Oxygen from hydroxide, the default anode reaction in any aqueous solution. */
+const OXYGEN = coupleById("O2/OH-");
+/**
+* What is reduced at the cathode.
+*
+* Molten salt has only one cation, so there is no competition and the metal always forms. In water
+* the metal ion competes with H⁺, and the winner is simply whichever couple has the higher
+* standard potential. That single comparison reproduces the whole "metals above hydrogen in the
+* reactivity series are not deposited from solution" rule without stating it separately.
+*/
+function cathodeOf(conditions) {
+	const couple = coupleById(conditions.electrolyte.cationCouple);
+	if (conditions.phase === "molten") return {
+		species: conditions.electrolyte.cation,
+		product: couple.reduced,
+		equation: half(couple, "reduce"),
+		electrons: couple.electrons,
+		because: "Molten salt contains no water, so the metal ion is the only cation present."
+	};
+	if (couple.standardPotential > HYDROGEN.standardPotential) return {
+		species: conditions.electrolyte.cation,
+		product: couple.reduced,
+		equation: half(couple, "reduce"),
+		electrons: couple.electrons,
+		because: `${couple.oxidised} is reduced more readily than H⁺ (${couple.standardPotential.toFixed(2)} V against 0.00 V), so the metal plates out.`,
+		insteadOf: "H₂"
+	};
+	return {
+		species: "water",
+		product: "H₂",
+		equation: "2H₂O + 2e⁻ → H₂ + 2OH⁻",
+		electrons: HYDROGEN.electrons,
+		because: `${couple.oxidised} holds its electrons harder than H⁺ does (${couple.standardPotential.toFixed(2)} V against 0.00 V), so water is reduced instead and the metal stays in solution.`,
+		insteadOf: couple.reduced
+	};
+}
+/**
+* What is oxidised at the anode.
+*
+* Three candidates in order of how easily they give electrons up: the electrode itself if it is
+* not inert, then a halide if there is one and it is concentrated enough, then hydroxide from the
+* water. An oxoanion is never a candidate at all.
+*/
+function anodeOf(conditions) {
+	const material = conditions.anodeMaterial ?? "inert";
+	const active = ACTIVE_ELECTRODE[material];
+	if (active) {
+		const electrons = active.electrons === 1 ? "e⁻" : `${active.electrons}e⁻`;
+		return {
+			species: `the ${material} anode`,
+			product: active.ion,
+			equation: `${active.symbol}(s) → ${active.ion}(aq) + ${electrons}`,
+			electrons: active.electrons,
+			because: "Oxidising the electrode itself is easier than oxidising anything dissolved, so the anode dissolves instead of releasing a gas.",
+			insteadOf: "O₂"
+		};
+	}
+	const anionCouple = conditions.electrolyte.anionCouple ? coupleById(conditions.electrolyte.anionCouple) : void 0;
+	if (!anionCouple) return {
+		species: "OH⁻ from water",
+		product: "O₂",
+		equation: half(OXYGEN, "oxidise"),
+		electrons: OXYGEN.electrons,
+		because: `${conditions.electrolyte.anion} is an oxoanion whose central atom is already fully oxidised, so it cannot be oxidised further and water goes instead.`,
+		insteadOf: conditions.electrolyte.anion
+	};
+	if (conditions.phase === "molten") return {
+		species: conditions.electrolyte.anion,
+		product: anionCouple.oxidised,
+		equation: half(anionCouple, "oxidise"),
+		electrons: anionCouple.electrons,
+		because: "Molten salt contains no water, so the halide is the only thing available to oxidise."
+	};
+	const concentration = conditions.concentration ?? 1;
+	if (concentration >= .5) return {
+		species: conditions.electrolyte.anion,
+		product: anionCouple.oxidised,
+		equation: half(anionCouple, "oxidise"),
+		electrons: anionCouple.electrons,
+		because: `At ${concentration} mol/dm³ the halide is concentrated enough to be discharged ahead of water.`,
+		insteadOf: "O₂"
+	};
+	return {
+		species: "OH⁻ from water",
+		product: "O₂",
+		equation: half(OXYGEN, "oxidise"),
+		electrons: OXYGEN.electrons,
+		because: `At ${concentration} mol/dm³ there is too little ${conditions.electrolyte.anion} to compete, so water is oxidised and oxygen comes off instead.`,
+		insteadOf: anionCouple.oxidised
+	};
+}
+/** Run the three competitions and report what each electrode does. */
+function electrolyse(conditions) {
+	const cathode = cathodeOf(conditions);
+	const anode = anodeOf(conditions);
+	return {
+		cathode,
+		anode,
+		solution: solutionChange(conditions, cathode, anode)
+	};
+}
+/**
+* What the solution becomes, which is the part a practical question asks about.
+*
+* The observable is usually here rather than at the electrodes: brine turning alkaline is how the
+* chlor-alkali industry makes sodium hydroxide, and copper sulfate keeping its blue with copper
+* electrodes but losing it with inert ones is the standard "explain the observation" question.
+*/
+function solutionChange(conditions, cathode, anode) {
+	if (conditions.phase === "molten") return "The melt is consumed as both elements are released.";
+	const metalStays = cathode.product === "H₂";
+	if (anode.species.includes("anode") && !metalStays) return "Unchanged: the anode dissolves at the same rate as the cathode plates, so the concentration holds steady.";
+	if (metalStays && anode.product !== "O₂") return `${conditions.electrolyte.cation} and OH⁻ are left behind, so the solution turns alkaline.`;
+	if (metalStays) return "Water is removed from both electrodes, so the solution becomes more concentrated.";
+	return `${conditions.electrolyte.cation} is removed from the solution, so its colour fades and the solution turns acidic.`;
+}
+
+//#endregion
+export { ELECTROLYTES, HALIDE_DISCHARGE_THRESHOLD, electrolyse, electrolyteByFormula };

package/dist/electro/faraday.d.mts

@@ -0,0 +1,150 @@
+//#region src/electro/faraday.d.ts
+/**
+ * Faraday's laws: how much stuff a given amount of charge moves.
+ *
+ * ## The whole topic is one conversion
+ *
+ *     Q = I t            charge is current times time
+ *     n(e⁻) = Q / F      one mole of electrons carries one faraday
+ *     n(substance) = n(e⁻) / z    where z is electrons per formula unit
+ *     m = n M
+ *
+ * Faraday's first law ("mass is proportional to charge") and second law ("equal charge deposits
+ * masses in the ratio of their equivalent weights") are both consequences of that chain, not extra
+ * rules. They were discovered before anyone knew electrons existed, which is why they are stated
+ * as proportionalities with an experimental constant; the chain above is the same content once you
+ * know what the constant counts.
+ *
+ * Both laws are still exposed, because a learner is asked for them by name, but they are computed
+ * from the chain so they cannot drift from it.
+ *
+ * ## z is per formula unit, and it is where the marks go
+ *
+ * Depositing one mole of copper from Cu²⁺ takes two moles of electrons; one mole of silver from
+ * Ag⁺ takes one; one mole of aluminium from Al³⁺ takes three. Passing one faraday through three
+ * cells in series therefore deposits 1 mol Ag, ½ mol Cu and ⅓ mol Al, which looks like three
+ * different answers and is one.
+ *
+ * ## The constant
+ *
+ * F = N_A · e = 96485.3 C/mol exactly by definition of the two. Books use 96500, which is a
+ * rounding of 0.015% and cannot be seen in a three-figure answer. This file uses the exact value.
+ *
+ * Pure: no React, no pixels.
+ */
+/** Charge in coulombs from a steady current. */
+declare const charge: (current: number, seconds: number) => number;
+/** Moles of electrons carried by a charge. */
+declare const molesOfElectrons: (coulombs: number) => number;
+/** The charge needed to move a given number of moles of electrons. */
+declare const chargeForElectrons: (moles: number) => number;
+interface Deposit {
+  /** Moles of electrons that passed. */
+  readonly electronMoles: number;
+  /** Moles of the substance deposited or dissolved. */
+  readonly moles: number;
+  /** Mass in grams. */
+  readonly mass: number;
+  /** Charge passed, coulombs. */
+  readonly charge: number;
+}
+interface DepositRequest {
+  /** Relative atomic or formula mass, g/mol. */
+  readonly molarMass: number;
+  /** Electrons per formula unit, e.g. 2 for Cu²⁺ → Cu. */
+  readonly electrons: number;
+  readonly current: number;
+  readonly seconds: number;
+}
+/**
+ * What a current deposits, in one pass.
+ *
+ * The four quantities are returned together rather than one at a time, because a question almost
+ * never asks for the mass alone: it asks for the mass and then the number of atoms, or the mass
+ * and then the change in solution concentration.
+ */
+declare function deposit({
+  molarMass,
+  electrons,
+  current,
+  seconds
+}: DepositRequest): Deposit;
+/**
+ * The current needed to deposit a given mass in a given time.
+ *
+ * The same relation solved the other way, which is how about half of these questions are set.
+ */
+declare const currentForMass: (mass: number, {
+  molarMass,
+  electrons,
+  seconds
+}: {
+  molarMass: number;
+  electrons: number;
+  seconds: number;
+}) => number;
+/** The time needed to deposit a given mass at a given current. */
+declare const timeForMass: (mass: number, {
+  molarMass,
+  electrons,
+  current
+}: {
+  molarMass: number;
+  electrons: number;
+  current: number;
+}) => number;
+/**
+ * Equivalent weight: the mass moved by one faraday.
+ *
+ * The quantity Faraday's second law is stated in, and the reason the law works without anyone
+ * knowing about electrons. It is just M/z.
+ */
+declare const equivalentWeight: (molarMass: number, electrons: number) => number;
+/**
+ * Electrochemical equivalent Z: grams per coulomb, so that m = Z Q.
+ *
+ * The first law's constant of proportionality. Worth having by name because older papers ask for
+ * it directly, and because it makes the first law a one-line check rather than a re-derivation.
+ */
+declare const electrochemicalEquivalent: (molarMass: number, electrons: number) => number;
+/**
+ * Faraday's second law as a ratio: equal charge moves masses in proportion to equivalent weights.
+ *
+ * This is the calculation for cells wired in SERIES, where the same charge necessarily passes
+ * through every one of them. That "necessarily" is the physics: series means one current, so the
+ * comparison needs no extra assumption.
+ */
+declare const massRatio: (a: {
+  molarMass: number;
+  electrons: number;
+}, b: {
+  molarMass: number;
+  electrons: number;
+}) => number;
+/**
+ * Volume of gas released, at a stated molar volume.
+ *
+ * Defaults to STP. A gas electrode's product is asked for as a volume far more often than as a
+ * mass, and converting through the mass loses the point: the electrons count particles, and a
+ * volume of gas is a count of particles.
+ */
+declare const gasVolume: (moles: number, molarVolume?: number) => number;
+/**
+ * Current efficiency: how much of the charge did the reaction you wanted.
+ *
+ * Rarely 100%. Plating nickel from an aqueous bath also reduces some water to hydrogen, so the
+ * metal actually deposited falls short of what the charge could have deposited. The gap is not
+ * experimental error, it is a second reaction sharing the current, which is why a real plating
+ * line is specified by efficiency as well as by current.
+ */
+declare const currentEfficiency: (actualMass: number, theoreticalMass: number) => number;
+/**
+ * The plated thickness a deposit corresponds to, in centimetres.
+ *
+ * Mass is what the charge determines and thickness is what the specification is written in, so
+ * this conversion through density and area is the last step of most real plating questions.
+ * Area in cm², density in g/cm³.
+ */
+declare const platedThickness: (mass: number, area: number, density: number) => number;
+//#endregion
+export { Deposit, DepositRequest, charge, chargeForElectrons, currentEfficiency, currentForMass, deposit, electrochemicalEquivalent, equivalentWeight, gasVolume, massRatio, molesOfElectrons, platedThickness, timeForMass };

package/dist/electro/faraday.mjs

@@ -0,0 +1,118 @@
+import { FARADAY, MOLAR_GAS_VOLUME_STP } from "../core/constants.mjs";
+
+//#region src/electro/faraday.ts
+/**
+* Faraday's laws: how much stuff a given amount of charge moves.
+*
+* ## The whole topic is one conversion
+*
+*     Q = I t            charge is current times time
+*     n(e⁻) = Q / F      one mole of electrons carries one faraday
+*     n(substance) = n(e⁻) / z    where z is electrons per formula unit
+*     m = n M
+*
+* Faraday's first law ("mass is proportional to charge") and second law ("equal charge deposits
+* masses in the ratio of their equivalent weights") are both consequences of that chain, not extra
+* rules. They were discovered before anyone knew electrons existed, which is why they are stated
+* as proportionalities with an experimental constant; the chain above is the same content once you
+* know what the constant counts.
+*
+* Both laws are still exposed, because a learner is asked for them by name, but they are computed
+* from the chain so they cannot drift from it.
+*
+* ## z is per formula unit, and it is where the marks go
+*
+* Depositing one mole of copper from Cu²⁺ takes two moles of electrons; one mole of silver from
+* Ag⁺ takes one; one mole of aluminium from Al³⁺ takes three. Passing one faraday through three
+* cells in series therefore deposits 1 mol Ag, ½ mol Cu and ⅓ mol Al, which looks like three
+* different answers and is one.
+*
+* ## The constant
+*
+* F = N_A · e = 96485.3 C/mol exactly by definition of the two. Books use 96500, which is a
+* rounding of 0.015% and cannot be seen in a three-figure answer. This file uses the exact value.
+*
+* Pure: no React, no pixels.
+*/
+/** Charge in coulombs from a steady current. */
+const charge = (current, seconds) => current * seconds;
+/** Moles of electrons carried by a charge. */
+const molesOfElectrons = (coulombs) => coulombs / FARADAY;
+/** The charge needed to move a given number of moles of electrons. */
+const chargeForElectrons = (moles) => moles * FARADAY;
+/**
+* What a current deposits, in one pass.
+*
+* The four quantities are returned together rather than one at a time, because a question almost
+* never asks for the mass alone: it asks for the mass and then the number of atoms, or the mass
+* and then the change in solution concentration.
+*/
+function deposit({ molarMass, electrons, current, seconds }) {
+	const q = charge(current, seconds);
+	const electronMoles = molesOfElectrons(q);
+	const moles = electronMoles / electrons;
+	return {
+		electronMoles,
+		moles,
+		mass: moles * molarMass,
+		charge: q
+	};
+}
+/**
+* The current needed to deposit a given mass in a given time.
+*
+* The same relation solved the other way, which is how about half of these questions are set.
+*/
+const currentForMass = (mass, { molarMass, electrons, seconds }) => mass / molarMass * electrons * FARADAY / seconds;
+/** The time needed to deposit a given mass at a given current. */
+const timeForMass = (mass, { molarMass, electrons, current }) => mass / molarMass * electrons * FARADAY / current;
+/**
+* Equivalent weight: the mass moved by one faraday.
+*
+* The quantity Faraday's second law is stated in, and the reason the law works without anyone
+* knowing about electrons. It is just M/z.
+*/
+const equivalentWeight = (molarMass, electrons) => molarMass / electrons;
+/**
+* Electrochemical equivalent Z: grams per coulomb, so that m = Z Q.
+*
+* The first law's constant of proportionality. Worth having by name because older papers ask for
+* it directly, and because it makes the first law a one-line check rather than a re-derivation.
+*/
+const electrochemicalEquivalent = (molarMass, electrons) => equivalentWeight(molarMass, electrons) / FARADAY;
+/**
+* Faraday's second law as a ratio: equal charge moves masses in proportion to equivalent weights.
+*
+* This is the calculation for cells wired in SERIES, where the same charge necessarily passes
+* through every one of them. That "necessarily" is the physics: series means one current, so the
+* comparison needs no extra assumption.
+*/
+const massRatio = (a, b) => equivalentWeight(a.molarMass, a.electrons) / equivalentWeight(b.molarMass, b.electrons);
+/**
+* Volume of gas released, at a stated molar volume.
+*
+* Defaults to STP. A gas electrode's product is asked for as a volume far more often than as a
+* mass, and converting through the mass loses the point: the electrons count particles, and a
+* volume of gas is a count of particles.
+*/
+const gasVolume = (moles, molarVolume = MOLAR_GAS_VOLUME_STP) => moles * molarVolume;
+/**
+* Current efficiency: how much of the charge did the reaction you wanted.
+*
+* Rarely 100%. Plating nickel from an aqueous bath also reduces some water to hydrogen, so the
+* metal actually deposited falls short of what the charge could have deposited. The gap is not
+* experimental error, it is a second reaction sharing the current, which is why a real plating
+* line is specified by efficiency as well as by current.
+*/
+const currentEfficiency = (actualMass, theoreticalMass) => theoreticalMass === 0 ? 0 : actualMass / theoreticalMass;
+/**
+* The plated thickness a deposit corresponds to, in centimetres.
+*
+* Mass is what the charge determines and thickness is what the specification is written in, so
+* this conversion through density and area is the last step of most real plating questions.
+* Area in cm², density in g/cm³.
+*/
+const platedThickness = (mass, area, density) => area === 0 || density === 0 ? 0 : mass / (area * density);
+
+//#endregion
+export { charge, chargeForElectrons, currentEfficiency, currentForMass, deposit, electrochemicalEquivalent, equivalentWeight, gasVolume, massRatio, molesOfElectrons, platedThickness, timeForMass };

package/dist/electro/index.d.mts

@@ -0,0 +1,6 @@
+import { COUPLES, Couple, Role, canReduce, coupleById, oxidationEquation, oxidationPotential, reductionEquation, strongerOxidant } from "./couples.mjs";
+import { Cell, HalfCellState, STANDARD_TEMPERATURE, anodeOxidationPotential, cellAsWritten, cellNotation, cellReaction, electrodePotential, electromotiveForce, freeEnergyFromPotential, galvanicCell, hydrogenElectrodePotential, nernstSlope, potentialFromFreeEnergy } from "./cell.mjs";
+import { Discharge, ELECTROLYTES, ElectrodeMaterial, ElectrolysisConditions, ElectrolysisResult, Electrolyte, HALIDE_DISCHARGE_THRESHOLD, Phase, electrolyse, electrolyteByFormula } from "./electrolysis.mjs";
+import { Deposit, DepositRequest, charge, chargeForElectrons, currentEfficiency, currentForMass, deposit, electrochemicalEquivalent, equivalentWeight, gasVolume, massRatio, molesOfElectrons, platedThickness, timeForMass } from "./faraday.mjs";
+import { cellConstant, conductance, conductivity, degreeOfDissociation, dissociationFromConstant, equivalentConductivity, limitingMolarConductivity, molarConductivity, molarVolumeOfSolution, ostwaldConstant, strongMolarConductivity, weakMolarConductivity } from "./conductivity.mjs";
+export { COUPLES, type Cell, type Couple, type Deposit, type DepositRequest, type Discharge, ELECTROLYTES, type ElectrodeMaterial, type ElectrolysisConditions, type ElectrolysisResult, type Electrolyte, HALIDE_DISCHARGE_THRESHOLD, type HalfCellState, type Phase, type Role, STANDARD_TEMPERATURE, anodeOxidationPotential, canReduce, cellAsWritten, cellConstant, cellNotation, cellReaction, charge, chargeForElectrons, conductance, conductivity, coupleById, currentEfficiency, currentForMass, degreeOfDissociation, deposit, dissociationFromConstant, electrochemicalEquivalent, electrodePotential, electrolyse, electrolyteByFormula, electromotiveForce, equivalentConductivity, equivalentWeight, freeEnergyFromPotential, galvanicCell, gasVolume, hydrogenElectrodePotential, limitingMolarConductivity, massRatio, molarConductivity, molarVolumeOfSolution, molesOfElectrons, nernstSlope, ostwaldConstant, oxidationEquation, oxidationPotential, platedThickness, potentialFromFreeEnergy, reductionEquation, strongMolarConductivity, strongerOxidant, timeForMass, weakMolarConductivity };

package/dist/electro/index.mjs

@@ -0,0 +1,7 @@
+import { COUPLES, canReduce, coupleById, oxidationEquation, oxidationPotential, reductionEquation, strongerOxidant } from "./couples.mjs";
+import { STANDARD_TEMPERATURE, anodeOxidationPotential, cellAsWritten, cellNotation, cellReaction, electrodePotential, electromotiveForce, freeEnergyFromPotential, galvanicCell, hydrogenElectrodePotential, nernstSlope, potentialFromFreeEnergy } from "./cell.mjs";
+import { ELECTROLYTES, HALIDE_DISCHARGE_THRESHOLD, electrolyse, electrolyteByFormula } from "./electrolysis.mjs";
+import { charge, chargeForElectrons, currentEfficiency, currentForMass, deposit, electrochemicalEquivalent, equivalentWeight, gasVolume, massRatio, molesOfElectrons, platedThickness, timeForMass } from "./faraday.mjs";
+import { cellConstant, conductance, conductivity, degreeOfDissociation, dissociationFromConstant, equivalentConductivity, limitingMolarConductivity, molarConductivity, molarVolumeOfSolution, ostwaldConstant, strongMolarConductivity, weakMolarConductivity } from "./conductivity.mjs";
+
+export { COUPLES, ELECTROLYTES, HALIDE_DISCHARGE_THRESHOLD, STANDARD_TEMPERATURE, anodeOxidationPotential, canReduce, cellAsWritten, cellConstant, cellNotation, cellReaction, charge, chargeForElectrons, conductance, conductivity, coupleById, currentEfficiency, currentForMass, degreeOfDissociation, deposit, dissociationFromConstant, electrochemicalEquivalent, electrodePotential, electrolyse, electrolyteByFormula, electromotiveForce, equivalentConductivity, equivalentWeight, freeEnergyFromPotential, galvanicCell, gasVolume, hydrogenElectrodePotential, limitingMolarConductivity, massRatio, molarConductivity, molarVolumeOfSolution, molesOfElectrons, nernstSlope, ostwaldConstant, oxidationEquation, oxidationPotential, platedThickness, potentialFromFreeEnergy, reductionEquation, strongMolarConductivity, strongerOxidant, timeForMass, weakMolarConductivity };

package/dist/finance/accounting/adjustments.d.mts

@@ -0,0 +1,17 @@
+import { AccountDefinition, AccountingPolicy, AccountingSolution, AdjustmentFact, AdjustmentResult, JournalEntry } from "./types.mjs";
+
+//#region src/finance/accounting/adjustments.d.ts
+declare function produceAdjustment(fact: AdjustmentFact, policy?: AccountingPolicy): AdjustmentResult;
+declare function applyAdjustments({
+  accounts,
+  baseEntries,
+  adjustments,
+  policy
+}: {
+  accounts: readonly AccountDefinition[];
+  baseEntries: readonly JournalEntry[];
+  adjustments: readonly AdjustmentFact[];
+  policy?: AccountingPolicy;
+}): AccountingSolution;
+//#endregion
+export { applyAdjustments, produceAdjustment };