@classytic/stage 0.2.0 → 0.4.0

package/dist/core/vec3.mjs

@@ -0,0 +1,123 @@
+//#region src/core/vec3.ts
+const v3 = (x, y, z) => ({
+	x,
+	y,
+	z
+});
+const ZERO3 = {
+	x: 0,
+	y: 0,
+	z: 0
+};
+const add3 = (a, b) => ({
+	x: a.x + b.x,
+	y: a.y + b.y,
+	z: a.z + b.z
+});
+const sub3 = (a, b) => ({
+	x: a.x - b.x,
+	y: a.y - b.y,
+	z: a.z - b.z
+});
+const scale3 = (a, k) => ({
+	x: a.x * k,
+	y: a.y * k,
+	z: a.z * k
+});
+const dot3 = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+/**
+* Right-handed cross product: a × b.
+*
+* The handedness is the whole content of this function. x̂ × ŷ = ẑ, which is
+* what makes the right-hand rule come out right everywhere downstream, from a
+* magnetic force to a torque to a surface normal.
+*/
+const cross3 = (a, b) => ({
+	x: a.y * b.z - a.z * b.y,
+	y: a.z * b.x - a.x * b.z,
+	z: a.x * b.y - a.y * b.x
+});
+const mag3 = (a) => Math.sqrt(dot3(a, a));
+const dist3 = (a, b) => mag3(sub3(a, b));
+/**
+* Unit vector, which THROWS on a zero vector rather than returning one.
+*
+* A zero-length direction is always a caller's mistake: a segment with no
+* length, a field point exactly on a source, an axis nobody set. Returning
+* `{0,0,0}` or dividing by a `|| 1` guard lets that mistake travel silently
+* into a picture, which is how a diagram ends up subtly wrong with every test
+* still green.
+*/
+const unit3 = (a) => {
+	const m = mag3(a);
+	if (m === 0) throw new RangeError("A zero-length vector has no direction.");
+	return scale3(a, 1 / m);
+};
+/** Linear interpolation, with t = 0 at `a` and t = 1 at `b`. */
+const lerp3 = (a, b, t) => add3(a, scale3(sub3(b, a), t));
+const midpoint3 = (a, b) => lerp3(a, b, .5);
+/** Angle between two vectors, in radians, clamped against floating-point drift. */
+const angleBetween3 = (a, b) => {
+	const denominator = mag3(a) * mag3(b);
+	if (denominator === 0) throw new RangeError("A zero-length vector has no angle.");
+	return Math.acos(Math.min(1, Math.max(-1, dot3(a, b) / denominator)));
+};
+/**
+* The component of `a` perpendicular to `onto`, with the parallel part removed.
+*
+* The workhorse of anything that needs an in-plane direction: a flux loop's
+* axes, a force resolved across a field, a distance from a line.
+*/
+const reject3 = (a, onto) => {
+	const n = unit3(onto);
+	return sub3(a, scale3(n, dot3(a, n)));
+};
+/** Shortest distance from a point to the segment ab, not to the infinite line. */
+const distToSegment3 = (p, a, b) => {
+	const ab = sub3(b, a);
+	const lengthSq = dot3(ab, ab);
+	if (lengthSq === 0) return dist3(p, a);
+	return dist3(p, add3(a, scale3(ab, Math.max(0, Math.min(1, dot3(sub3(p, a), ab) / lengthSq)))));
+};
+/**
+* Two perpendicular unit vectors spanning the plane with this normal.
+*
+* A `preferred` direction becomes the FIRST axis, projected into the plane.
+* Note that it must be projected and not merely passed to a cross product:
+* `cross(preferred, n)` returns something perpendicular to `preferred`, which
+* silently swaps the two axes and hands back a frame the caller did not ask
+* for. That bug cost real time in the flux integrator.
+*/
+const basisFor3 = (normal, preferred) => {
+	const n = unit3(normal);
+	if (preferred) {
+		const inPlane = sub3(preferred, scale3(n, dot3(preferred, n)));
+		if (mag3(inPlane) > 1e-9) {
+			const u = unit3(inPlane);
+			return [u, cross3(n, u)];
+		}
+	}
+	const u = unit3(cross3(Math.abs(n.z) < .9 ? v3(0, 0, 1) : v3(1, 0, 0), n));
+	return [u, cross3(n, u)];
+};
+const vec3 = {
+	v: v3,
+	add: add3,
+	sub: sub3,
+	scale: scale3,
+	dot: dot3,
+	cross: cross3,
+	mag: mag3,
+	dist: dist3,
+	unit: unit3,
+	lerp: lerp3,
+	midpoint: midpoint3,
+	angleBetween: angleBetween3,
+	reject: reject3,
+	distToSegment: distToSegment3,
+	basisFor: basisFor3,
+	ZERO: ZERO3
+};
+
+//#endregion
+export { ZERO3, add3, angleBetween3, basisFor3, cross3, dist3, distToSegment3, dot3, lerp3, mag3, midpoint3, reject3, scale3, sub3, unit3, v3, vec3 };

package/dist/core/worked.d.mts

@@ -0,0 +1,35 @@
+//#region src/core/worked.d.ts
+/**
+ * Worked calculations: the shape a kernel uses to SHOW ITS WORKING.
+ *
+ * A kernel that returns only an answer cannot teach. This is the data a kernel emits instead: the
+ * value plus every substitution and simplification that produced it, each as a LaTeX line with an
+ * optional note saying why that step follows. Pure and dependency-free; rendering is somebody
+ * else's job (in labs, `kit/rule`'s RuleCard and WorkedSteps).
+ *
+ * It lives in stage rather than in labs because the kernels are what produce it. A relation solver
+ * or a redox balancer that emits worked steps cannot describe its own return type if the type
+ * lives in a consumer. The renderer can stay downstream; the shape cannot.
+ */
+/** One line of a worked calculation: a LaTeX expression + an optional plain note. */
+interface CalcStep {
+  tex: string;
+  /** Why this step follows ("substitute n = 5", "the falling product"). */
+  note?: string;
+}
+/** The result of a worked calculation: the final value + the steps that got there. */
+interface Worked {
+  value: number;
+  steps: CalcStep[];
+}
+/** A tiny fluent builder: calc().step('…','…').step('…').done(value). */
+declare class Calc {
+  private readonly _steps;
+  step(tex: string, note?: string): this;
+  done(value: number): Worked;
+}
+declare const calc: () => Calc;
+/** Format a number for inline LaTeX (thin-space thousands so big counts read). */
+declare function texNum(n: number): string;
+//#endregion
+export { Calc, CalcStep, Worked, calc, texNum };

package/dist/core/worked.mjs

@@ -0,0 +1,44 @@
+//#region src/core/worked.ts
+/** A tiny fluent builder: calc().step('…','…').step('…').done(value). */
+var Calc = class {
+	_steps = [];
+	step(tex, note) {
+		this._steps.push(note === void 0 ? { tex } : {
+			tex,
+			note
+		});
+		return this;
+	}
+	done(value) {
+		return {
+			value,
+			steps: this._steps
+		};
+	}
+};
+const calc = () => new Calc();
+/** Format a number for inline LaTeX (thin-space thousands so big counts read). */
+function texNum(n) {
+	if (!Number.isFinite(n)) return "\\text{?}";
+	return Math.abs(n) >= 1e4 ? n.toLocaleString("en-US").replace(/,/g, "{,}") : String(n);
+}
+/**
+* A number to `sf` significant figures, in LaTeX, using exponent notation only when the plain
+* decimal would be unreadable.
+*
+* Every kernel that shows working needs this and they must all round the same way, or two
+* derivations of the same quantity disagree in their last digit and a student reasonably concludes
+* one of them is wrong.
+*/
+function texSigFigs(value, sf = 3) {
+	if (!Number.isFinite(value)) return "\\text{?}";
+	const abs = Math.abs(value);
+	if (abs !== 0 && (abs < .001 || abs >= 1e6)) {
+		const [mantissa, exponent] = value.toExponential(sf - 1).split("e");
+		return `${mantissa} \\times 10^{${Number(exponent)}}`;
+	}
+	return String(Number(value.toPrecision(sf)));
+}
+
+//#endregion
+export { Calc, calc, texNum, texSigFigs };

package/dist/electro/cell.d.mts

@@ -0,0 +1,102 @@
+import { Couple } from "./couples.mjs";
+
+//#region src/electro/cell.d.ts
+/** Standard temperature for electrode potentials, kelvin (25 °C). */
+declare const STANDARD_TEMPERATURE = 298.15;
+interface HalfCellState {
+  readonly couple: Couple;
+  /**
+   * Concentrations and partial pressures for the species in this couple's quotient, keyed as the
+   * quotient keys them. Anything omitted is taken as standard, which is 1.
+   */
+  readonly activities?: Readonly<Record<string, number>>;
+}
+interface Cell {
+  readonly cathode: HalfCellState;
+  readonly anode: HalfCellState;
+  /** Electrons transferred by the balanced cell reaction. */
+  readonly electrons: number;
+  /** E°cell in volts, from standard potentials alone. */
+  readonly standardPotential: number;
+  /** The reaction quotient for the cell reaction as written. */
+  readonly quotient: number;
+  /** The actual potential under the stated conditions, volts. */
+  readonly potential: number;
+  /** ΔG under those conditions, joules per mole of reaction. */
+  readonly freeEnergy: number;
+  /** ΔG° under standard conditions, joules per mole of reaction. */
+  readonly standardFreeEnergy: number;
+  /** The equilibrium constant for the cell reaction. */
+  readonly equilibriumConstant: number;
+  /** Does the reaction run as written? */
+  readonly spontaneous: boolean;
+  readonly temperature: number;
+}
+/**
+ * Build a cell from two half-cells, assigning the electrodes by potential.
+ *
+ * Which half-cell is the cathode is a consequence of the numbers, not an input. The higher
+ * standard potential reduces; on a tie, which is a concentration cell with the same couple on both
+ * sides, the more concentrated side reduces, and that is the only case where the electrodes are
+ * decided by anything other than E°.
+ */
+declare function galvanicCell(first: HalfCellState, second: HalfCellState, temperature?: number): Cell;
+/**
+ * Build the cell exactly as written, cathode on the right, without reassigning the electrodes.
+ *
+ * For a cell someone has written down and wants checked. A cell notation written the wrong way
+ * round has a negative potential, and that is the useful answer: it says the reaction goes the
+ * other way. Reordering it silently would answer a question nobody asked.
+ */
+declare const cellAsWritten: (anode: HalfCellState, cathode: HalfCellState, temperature?: number) => Cell;
+/**
+ * The cell in the standard notation, anode on the left.
+ *
+ *     Zn(s) | Zn²⁺(aq) || Cu²⁺(aq) | Cu(s)
+ *
+ * The double bar is the salt bridge and the convention is not decoration: oxidation is written on
+ * the left because that is the direction electrons travel through the external wire, so a cell
+ * read left to right is a cell read in the direction the electrons move.
+ */
+declare function cellNotation(cell: Cell): string;
+/** The balanced overall reaction, both halves scaled to the same electron count. */
+declare function cellReaction(cell: Cell): string;
+/**
+ * The potential of a single electrode against the standard hydrogen electrode, under Nernst.
+ *
+ * This is what a measurement against the SHE actually reads, and it is the quantity the hydrogen
+ * electrode's own definition makes meaningful. Building it as a cell against hydrogen rather than
+ * as its own formula keeps one Nernst implementation in the file instead of two.
+ */
+declare const electrodePotential: (state: HalfCellState, temperature?: number) => number;
+/**
+ * How a hydrogen electrode's potential reports the pH of the solution it stands in.
+ *
+ * At 25 °C the Nernst term collapses to 0.0592 volts per pH unit, which is why a pH meter is an
+ * electrochemical instrument rather than a chemical one. The coefficient is computed from the
+ * constants rather than typed in, so it stays right at any temperature.
+ */
+declare const hydrogenElectrodePotential: (pH: number, temperature?: number) => number;
+/** The volts-per-pH-unit slope, 0.0592 V at 25 °C. */
+declare const nernstSlope: (temperature?: number) => number;
+/**
+ * Free energy from a cell potential, and back.
+ *
+ * Separate from {@link Cell} on purpose: a learner is regularly given E and asked for ΔG with no
+ * cell in hand, and the conversion is the point of the question.
+ */
+declare const freeEnergyFromPotential: (electrons: number, potential: number) => number;
+declare const potentialFromFreeEnergy: (electrons: number, freeEnergy: number) => number;
+/**
+ * The EMF a cell presents to a circuit.
+ *
+ * The seam to the circuit kernel. A chemical cell driving a lamp is a voltage source in series
+ * with an internal resistance, and the chemistry decides only the source value; everything after
+ * that is Kirchhoff and belongs to the circuit solver rather than here. Terminal voltage is
+ * deliberately NOT computed in this file, because a cell under load is a circuit question.
+ */
+declare const electromotiveForce: (cell: Cell) => number;
+/** Oxidation potential of a half-cell's couple, for the convention that prefers it. */
+declare const anodeOxidationPotential: (cell: Cell) => number;
+//#endregion
+export { Cell, HalfCellState, STANDARD_TEMPERATURE, anodeOxidationPotential, cellAsWritten, cellNotation, cellReaction, electrodePotential, electromotiveForce, freeEnergyFromPotential, galvanicCell, hydrogenElectrodePotential, nernstSlope, potentialFromFreeEnergy };

package/dist/electro/cell.mjs

@@ -0,0 +1,170 @@
+import { FARADAY, GAS_CONSTANT } from "../core/constants.mjs";
+import { coupleById, oxidationPotential } from "./couples.mjs";
+
+//#region src/electro/cell.ts
+/**
+* A galvanic cell: which way it runs, how hard, and what that says about the reaction.
+*
+* ## The three statements that are the same statement
+*
+* A learner meets cell potential, free energy and the equilibrium constant as three topics. They
+* are one quantity written three ways:
+*
+*     ΔG° = −nFE°cell          and          ΔG° = −RT ln K
+*
+* so E°cell and K carry exactly the same information, and "will it react" has one answer in three
+* currencies. This file computes all three from the same cell rather than offering three formulas,
+* because a learner who can convert between them has understood something and one who has three
+* formulas has three things to forget.
+*
+* ## Sign, which is where this topic actually goes wrong
+*
+*     E°cell = E°(cathode) − E°(anode)          both as REDUCTION potentials
+*
+* The cathode is where reduction happens, and it is the half-cell with the higher reduction
+* potential. That single rule fixes every sign in the file. Textbooks that write
+* "E°cell = E°(anode, oxidation) + E°(cathode, reduction)" are saying the same thing, since an
+* oxidation potential is a reduction potential negated.
+*
+* A cell written down the WRONG way round is not an error to hide. Its potential comes out
+* negative, which is the cell telling you it runs the other way, and {@link cellFromNotation}
+* keeps that answer rather than quietly swapping the electrodes.
+*
+* ## Faraday's constant is derived, not 96500
+*
+* F = N_A · e exactly, which is 96485.3 C/mol. Books round it to 96500, a shift of 0.015%, and
+* that is invisible in a two-significant-figure answer. This file uses the exact value: rounding a
+* constant to make a worked answer land is how a kernel starts lying.
+*
+* Pure: no React, no pixels.
+*/
+/** Standard temperature for electrode potentials, kelvin (25 °C). */
+const STANDARD_TEMPERATURE = 298.15;
+const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+const lcm = (a, b) => a * b / gcd(a, b);
+/**
+* The activity of one species, defaulting to standard.
+*
+* A missing entry means "standard", never zero. Zero would send a logarithm to infinity and hand
+* back a potential of ±Infinity, which looks like a physical answer and is not one.
+*/
+const activityOf = (state, species) => state.activities?.[species] ?? 1;
+/**
+* The reaction quotient for the whole cell, built from both half-cells.
+*
+* The cathode half runs as reduction and the anode half runs backwards, so the anode's quotient
+* contributions are inverted. Each is also raised to the factor that scales its half-equation up
+* to the cell's electron count, which is the step most hand-worked answers drop when the two
+* half-cells transfer different numbers of electrons.
+*/
+function quotientOf(cathode, anode, electrons) {
+	let q = 1;
+	const cathodeScale = electrons / cathode.couple.electrons;
+	for (const [species, power] of Object.entries(cathode.couple.quotient)) q *= activityOf(cathode, species) ** (-power * cathodeScale);
+	const anodeScale = electrons / anode.couple.electrons;
+	for (const [species, power] of Object.entries(anode.couple.quotient)) q *= activityOf(anode, species) ** (power * anodeScale);
+	return q;
+}
+/**
+* Build a cell from two half-cells, assigning the electrodes by potential.
+*
+* Which half-cell is the cathode is a consequence of the numbers, not an input. The higher
+* standard potential reduces; on a tie, which is a concentration cell with the same couple on both
+* sides, the more concentrated side reduces, and that is the only case where the electrodes are
+* decided by anything other than E°.
+*/
+function galvanicCell(first, second, temperature = STANDARD_TEMPERATURE) {
+	const firstIsCathode = first.couple.standardPotential === second.couple.standardPotential ? concentrationOf(first) >= concentrationOf(second) : first.couple.standardPotential > second.couple.standardPotential;
+	return assemble(firstIsCathode ? first : second, firstIsCathode ? second : first, temperature);
+}
+/**
+* Build the cell exactly as written, cathode on the right, without reassigning the electrodes.
+*
+* For a cell someone has written down and wants checked. A cell notation written the wrong way
+* round has a negative potential, and that is the useful answer: it says the reaction goes the
+* other way. Reordering it silently would answer a question nobody asked.
+*/
+const cellAsWritten = (anode, cathode, temperature = STANDARD_TEMPERATURE) => assemble(cathode, anode, temperature);
+function assemble(cathode, anode, temperature) {
+	const electrons = lcm(cathode.couple.electrons, anode.couple.electrons);
+	const standardPotential = cathode.couple.standardPotential - anode.couple.standardPotential;
+	const quotient = quotientOf(cathode, anode, electrons);
+	const potential = standardPotential - GAS_CONSTANT * temperature / (electrons * FARADAY) * Math.log(quotient);
+	return {
+		cathode,
+		anode,
+		electrons,
+		standardPotential,
+		quotient,
+		potential,
+		freeEnergy: -electrons * FARADAY * potential,
+		standardFreeEnergy: -electrons * FARADAY * standardPotential,
+		equilibriumConstant: Math.exp(electrons * FARADAY * standardPotential / (GAS_CONSTANT * temperature)),
+		spontaneous: potential > 0,
+		temperature
+	};
+}
+/** The ion concentration a half-cell is at, for the concentration-cell tie-break. */
+function concentrationOf(state) {
+	const [species] = Object.keys(state.couple.quotient);
+	return species === void 0 ? 1 : activityOf(state, species);
+}
+/**
+* The cell in the standard notation, anode on the left.
+*
+*     Zn(s) | Zn²⁺(aq) || Cu²⁺(aq) | Cu(s)
+*
+* The double bar is the salt bridge and the convention is not decoration: oxidation is written on
+* the left because that is the direction electrons travel through the external wire, so a cell
+* read left to right is a cell read in the direction the electrons move.
+*/
+function cellNotation(cell) {
+	return `${`${cell.anode.couple.reduced} | ${cell.anode.couple.oxidised}`} || ${`${cell.cathode.couple.oxidised} | ${cell.cathode.couple.reduced}`}`;
+}
+/** The balanced overall reaction, both halves scaled to the same electron count. */
+function cellReaction(cell) {
+	const anodeScale = cell.electrons / cell.anode.couple.electrons;
+	const cathodeScale = cell.electrons / cell.cathode.couple.electrons;
+	const term = (n, species) => n === 1 ? species : `${n}${species}`;
+	return `${term(anodeScale, cell.anode.couple.reduced)} + ${term(cathodeScale, cell.cathode.couple.oxidised)} → ${term(anodeScale, cell.anode.couple.oxidised)} + ${term(cathodeScale, cell.cathode.couple.reduced)}`;
+}
+/**
+* The potential of a single electrode against the standard hydrogen electrode, under Nernst.
+*
+* This is what a measurement against the SHE actually reads, and it is the quantity the hydrogen
+* electrode's own definition makes meaningful. Building it as a cell against hydrogen rather than
+* as its own formula keeps one Nernst implementation in the file instead of two.
+*/
+const electrodePotential = (state, temperature = STANDARD_TEMPERATURE) => assemble(state, { couple: coupleById("H+/H2") }, temperature).potential;
+/**
+* How a hydrogen electrode's potential reports the pH of the solution it stands in.
+*
+* At 25 °C the Nernst term collapses to 0.0592 volts per pH unit, which is why a pH meter is an
+* electrochemical instrument rather than a chemical one. The coefficient is computed from the
+* constants rather than typed in, so it stays right at any temperature.
+*/
+const hydrogenElectrodePotential = (pH, temperature = STANDARD_TEMPERATURE) => -(GAS_CONSTANT * temperature * Math.LN10 / FARADAY) * pH;
+/** The volts-per-pH-unit slope, 0.0592 V at 25 °C. */
+const nernstSlope = (temperature = STANDARD_TEMPERATURE) => GAS_CONSTANT * temperature * Math.LN10 / FARADAY;
+/**
+* Free energy from a cell potential, and back.
+*
+* Separate from {@link Cell} on purpose: a learner is regularly given E and asked for ΔG with no
+* cell in hand, and the conversion is the point of the question.
+*/
+const freeEnergyFromPotential = (electrons, potential) => -electrons * FARADAY * potential;
+const potentialFromFreeEnergy = (electrons, freeEnergy) => -freeEnergy / (electrons * FARADAY);
+/**
+* The EMF a cell presents to a circuit.
+*
+* The seam to the circuit kernel. A chemical cell driving a lamp is a voltage source in series
+* with an internal resistance, and the chemistry decides only the source value; everything after
+* that is Kirchhoff and belongs to the circuit solver rather than here. Terminal voltage is
+* deliberately NOT computed in this file, because a cell under load is a circuit question.
+*/
+const electromotiveForce = (cell) => cell.potential;
+/** Oxidation potential of a half-cell's couple, for the convention that prefers it. */
+const anodeOxidationPotential = (cell) => oxidationPotential(cell.anode.couple);
+
+//#endregion
+export { STANDARD_TEMPERATURE, anodeOxidationPotential, cellAsWritten, cellNotation, cellReaction, electrodePotential, electromotiveForce, freeEnergyFromPotential, galvanicCell, hydrogenElectrodePotential, nernstSlope, potentialFromFreeEnergy };

package/dist/electro/conductivity.d.mts

@@ -0,0 +1,157 @@
+//#region src/electro/conductivity.d.ts
+/**
+ * How well a solution conducts, and the three quantities that all get called "conductivity".
+ *
+ * ## Three quantities, three different questions
+ *
+ *   conductance G = 1/R                 this SAMPLE, in this cell.        siemens
+ *   conductivity κ = G · (l/A)          this SOLUTION, cell removed.      S/cm
+ *   molar conductivity Λm = κ / c       one MOLE of it, dilution removed. S·cm²/mol
+ *
+ * Each strips away one thing the one before it still depends on. Conductance depends on the
+ * electrodes' spacing and area, so two labs measuring the same solution disagree. Conductivity
+ * removes the cell through its geometry (l/A, the cell constant) and is a property of the
+ * solution, but it still falls as the solution is diluted, simply because there are fewer ions.
+ * Molar conductivity divides that out and asks what one mole contributes wherever it is.
+ *
+ * The payoff is the last one. Molar conductivity RISES on dilution, which sounds backwards until
+ * you see it is measuring per mole while conductivity measures per volume. For a strong
+ * electrolyte it rises a little and levels off, because the ions were already fully separated and
+ * only get out of each other's way. For a weak one it climbs steeply without ever levelling,
+ * because dilution is pushing its dissociation equilibrium further over: at ordinary
+ * concentrations most of the acetic acid in a beaker is not ionised at all.
+ *
+ * That difference is the measurement's whole diagnostic value. It tells strong from weak
+ * electrolytes without any chemistry beyond a resistance reading.
+ *
+ * ## Units, and the trap in them
+ *
+ * Everything here is in the CENTIMETRE units this topic is universally taught and examined in:
+ * cm for the electrode spacing, cm² for the area, cm³ for volume, mol/dm³ for concentration. That
+ * last one is the trap, because a concentration in mol/dm³ and a volume in cm³ differ by the
+ * factor of 1000 that {@link molarConductivity} carries. Mixing the two is the commonest wrong
+ * answer in the topic, and it is wrong by exactly a thousand, which is large enough to spot and
+ * quiet enough to miss.
+ *
+ * Pure: no React, no pixels.
+ */
+/**
+ * Cell constant l/A, in cm⁻¹: the geometry that turns a measured conductance into a property.
+ *
+ * Measured in practice rather than calculated, by putting a solution of known conductivity
+ * (standard KCl) in the cell and reading what it gives. The electrodes are never quite the flat
+ * parallel plates the formula assumes.
+ */
+declare const cellConstant: (separationCm: number, areaCm2: number) => number;
+/** Conductance in siemens, the reciprocal of the measured resistance. */
+declare const conductance: (resistanceOhm: number) => number;
+/**
+ * Conductivity κ in S/cm: the solution's own property, with the cell divided out.
+ *
+ * Also called specific conductance. It is the conductance a centimetre cube of the solution would
+ * show between opposite faces, which is why the units carry a length.
+ */
+declare const conductivity: (resistanceOhm: number, cellConstantPerCm: number) => number;
+/**
+ * Molar conductivity Λm in S·cm²/mol, from conductivity and concentration in mol/dm³.
+ *
+ * The 1000 converts dm³ to cm³. It is not a fudge factor: κ is per cubic centimetre and c is per
+ * cubic decimetre, and the conversion has to appear somewhere. Here, once, rather than in every
+ * caller.
+ */
+declare const molarConductivity: (conductivityScm: number, concentrationMolPerDm3: number) => number;
+/**
+ * Equivalent conductivity in S·cm²/equivalent, for the older papers that ask for it.
+ *
+ * Same quantity per EQUIVALENT rather than per mole, so it differs by the number of charges the
+ * formula unit carries. Sulfuric acid supplies two hydrogen ions per molecule, so a solution
+ * 0.5 mol/dm³ in H₂SO₄ is 1 equivalent per cubic decimetre, and its equivalent conductivity is
+ * half its molar conductivity. Worth keeping, because the two are quoted interchangeably in older
+ * sources and differ by a factor nobody signposts.
+ */
+declare const equivalentConductivity: (conductivityScm: number, concentrationMolPerDm3: number, chargesPerFormulaUnit: number) => number;
+/**
+ * Volume in cm³ holding one mole, from a concentration in mol/dm³.
+ *
+ * The form older texts state the relation in: Λm = κ · V. Same content as dividing by
+ * concentration, and worth exposing because a question phrased with V is asking for this.
+ */
+declare const molarVolumeOfSolution: (concentrationMolPerDm3: number) => number;
+/**
+ * Degree of dissociation from molar conductivity, against its value at infinite dilution.
+ *
+ * Arrhenius's ratio: at infinite dilution a weak electrolyte is fully dissociated, so how far
+ * short of that a real solution falls is how far short of fully dissociated it is. This is the
+ * measurement that makes "weak acid" a number rather than a word.
+ *
+ * Λ°m cannot be reached by extrapolating a weak electrolyte's own curve, because it is still
+ * climbing steeply where the data runs out. It is assembled from ion conductivities instead, which
+ * is what Kohlrausch's law is for.
+ */
+declare const degreeOfDissociation: (molar: number, atInfiniteDilution: number) => number;
+/**
+ * Λ°m for an electrolyte from its separate ions (Kohlrausch's law of independent migration).
+ *
+ * At infinite dilution the ions are far enough apart to ignore each other entirely, so each
+ * contributes the same amount whatever it arrived with. That independence is the claim, and it is
+ * what lets a weak acid's Λ°m be assembled from strong-electrolyte measurements it could never be
+ * extrapolated from directly.
+ */
+declare const limitingMolarConductivity: (cation: {
+  conductivity: number;
+  count: number;
+}, anion: {
+  conductivity: number;
+  count: number;
+}) => number;
+/**
+ * The dissociation constant of a weak electrolyte from its conductivity (Ostwald's dilution law).
+ *
+ *     K = c α² / (1 − α)
+ *
+ * The bridge between an electrical measurement and an equilibrium constant, and the reason this
+ * technique mattered historically: it gives Ka for an acid too weak to titrate accurately.
+ */
+declare const ostwaldConstant: (concentrationMolPerDm3: number, dissociation: number) => number;
+/**
+ * How far a weak electrolyte dissociates at a given concentration, from its constant.
+ *
+ * Ostwald's law run the other way, and the direction that actually gets used: the constant is the
+ * fixed property and the concentration is what a learner changes. Solving cα² + Kα − K = 0 for the
+ * positive root,
+ *
+ *     α = (−K + √(K² + 4cK)) / 2c
+ *
+ * written that way rather than as the textbook quadratic because the other arrangement subtracts
+ * two nearly equal numbers when K is small, which is exactly the case here: cancellation would eat
+ * most of the significant figures for an acid with a K of 10⁻⁵.
+ *
+ * This is what makes dilution visible. Acetic acid is about 1.3% ionised at 0.1 mol/dm³ and about
+ * 13% at 0.001, so its molar conductivity climbs steeply on dilution while a strong electrolyte's
+ * barely moves.
+ */
+declare function dissociationFromConstant(concentrationMolPerDm3: number, dissociationConstant: number): number;
+/**
+ * Molar conductivity of a STRONG electrolyte at a real concentration (Kohlrausch's √c law).
+ *
+ *     Λm = Λ°m − A√c
+ *
+ * A strong electrolyte is fully dissociated at every concentration, so its molar conductivity has
+ * no dissociation to change. What little it loses on concentrating is the ions getting in each
+ * other's way: an ion drags an oppositely charged atmosphere behind it, and the closer they are
+ * packed the more it drags.
+ *
+ * That is the whole diagnostic. The square-root fall is gentle and levels off; a weak
+ * electrolyte's rise does not level off at all, because its dissociation is still moving. Told
+ * apart by the SHAPE of the curve, without knowing anything else about either substance.
+ */
+declare const strongMolarConductivity: (limiting: number, slope: number, concentrationMolPerDm3: number) => number;
+/**
+ * Molar conductivity of a WEAK electrolyte, which is its limit scaled by how far it has gone.
+ *
+ * Λm = α Λ°m, with α from the dissociation constant. The same statement as
+ * {@link degreeOfDissociation} solved for the conductivity instead of the ratio.
+ */
+declare const weakMolarConductivity: (limiting: number, dissociationConstant: number, concentrationMolPerDm3: number) => number;
+//#endregion
+export { cellConstant, conductance, conductivity, degreeOfDissociation, dissociationFromConstant, equivalentConductivity, limitingMolarConductivity, molarConductivity, molarVolumeOfSolution, ostwaldConstant, strongMolarConductivity, weakMolarConductivity };