@classytic/stage 0.2.0 → 0.4.0

package/dist/physics/gravitation/variation.d.mts

@@ -0,0 +1,97 @@
+import { Worked } from "../../core/worked.mjs";
+import { CentralBody } from "./body.mjs";
+
+//#region src/physics/gravitation/variation.d.ts
+/**
+ * `g` at a height above the surface: `g' = g·R²/(R+h)²`.
+ *
+ * Equivalently `mu/(R+h)²`, which is the same statement with the surface value never mentioned. The
+ * error this guards against is using `h` where `R + h` belongs: at 400 km the International Space
+ * Station has `g` of about 8.7 m/s², which is 89% of the surface value, NOT zero. Astronauts float
+ * because they are falling, not because gravity has run out, and the number is how you prove it.
+ */
+declare const gravityAtHeight: (body: CentralBody, height: number) => number;
+/**
+ * The same, worked, including the small-height approximation and where it stops being honest.
+ *
+ * `g' ≈ g(1 − 2h/R)` is the binomial expansion, and the FACTOR OF TWO in it is the thing to notice:
+ * it is what makes climbing cost twice what descending costs. The working reports both the exact
+ * value and the approximation so a learner can see the gap open up as `h` grows.
+ */
+declare function gravityAtHeightSteps(body: CentralBody, height: number, sf?: number): Worked;
+/**
+ * The height at which `g` has fallen to a given fraction of its surface value.
+ *
+ * `h = R(1/√f − 1)`. Half of `g` is at `h = 0.414R`, roughly 2600 km up, which is a useful shock: `g`
+ * is still a quarter of its surface value out where the geostationary satellites are not, and
+ * halving it takes you a third of the way to the Moon's distance in radii but nowhere near it.
+ */
+declare function heightForGravityFraction(body: CentralBody, fraction: number): number;
+/** The height at which `g` takes a given value, m. Throws if that value exceeds the surface value. */
+declare function heightForGravity(body: CentralBody, target: number): number;
+/**
+ * `g` at a depth below the surface: `g' = g(1 − d/R)`, for a body of uniform density.
+ *
+ * A STRAIGHT LINE, reaching exactly zero at the centre, which is the half of the picture students
+ * never draw. It follows from the shell theorem: the mass further out than you contributes nothing,
+ * so only the sphere of radius `R − d` beneath you pulls, and its mass falls as the cube while the
+ * distance falls as the square, leaving one power of the radius.
+ *
+ * "Uniform density" is a genuine idealisation and not a small one. The real Earth has a dense iron
+ * core, so `g` actually RISES slightly on the way down and peaks near the core-mantle boundary at
+ * around 10.7 m/s² before falling. Worth saying out loud in a lesson: the formula is exactly right
+ * for the model and the model is not the Earth.
+ */
+declare function gravityAtDepth(body: CentralBody, depth: number): number;
+/**
+ * The height and the depth at which `g` has the same value, side by side.
+ *
+ * Built as one function because the question is always asked as a comparison, and the comparison is
+ * the entire lesson: to lose a given fraction of `g` you must climb only about half as far as you
+ * would have to dig. Returns both distances in metres plus the working that puts the factor of two
+ * where a learner can see it.
+ */
+declare function equalGravityDepthAndHeight(body: CentralBody, fraction: number, sf?: number): {
+  height: number;
+  depth: number;
+  worked: Worked;
+};
+/**
+ * Apparent `g` at a latitude on a rotating body: `g' = g − ω²R cos²λ`.
+ *
+ * The centripetal term comes from `rotation/circular.ts`, because it IS the centripetal
+ * acceleration and a learner should recognise it rather than meet it as a new formula. The radius
+ * of the circle a point actually travels is `R cos λ`, not `R`, which is where the cosine enters
+ * and where the square comes from: one factor from the smaller circle, one from `ω²r`.
+ *
+ * At the pole the correction is exactly zero, because a point on the axis goes nowhere. At the
+ * equator it is largest, at about 0.034 m/s², which is roughly 0.35% and is why `g` reads about 9.78
+ * at the equator against 9.83 at the poles. The full 0.05 difference also includes the Earth's
+ * equatorial bulge, which this does not model: a rotating planet is not a sphere, and the rotation
+ * is the reason for both effects.
+ */
+declare function gravityAtLatitude(body: CentralBody, latitudeDeg: number): number;
+/**
+ * How fast a body would have to spin for things at its equator to float free: `T = 2π√(R/g)`.
+ *
+ * The rotation at which the whole of `g` is used up supplying the centripetal requirement, so a
+ * scale at the equator reads zero. For the Earth this is about 84 minutes, so the day would have to
+ * shorten by a factor of roughly 17: that number is the answer to the textbook question, and it is
+ * also the orbital period of a satellite skimming the surface, which is not a coincidence. Both ask
+ * the same thing: what speed does gravity alone hold in a circle of radius `R`?
+ */
+declare function spinPeriodForWeightlessness(body: CentralBody, sf?: number): Worked;
+/**
+ * Weight, m/s² times kg, at a stated place on or above a body.
+ *
+ * A convenience with a purpose: it forces the CHOICE of which variation applies to be named, rather
+ * than a lesson silently using the surface value everywhere. Exactly one of `height`, `depth` or
+ * `latitudeDeg` may be given.
+ */
+declare function weightAt(body: CentralBody, mass: number, place?: {
+  height?: number;
+  depth?: number;
+  latitudeDeg?: number;
+}): number;
+//#endregion
+export { equalGravityDepthAndHeight, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, spinPeriodForWeightlessness, weightAt };

package/dist/physics/gravitation/variation.mjs

@@ -0,0 +1,175 @@
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { toRadians } from "../vectors.mjs";
+import { centripetalAcceleration } from "../rotation/circular.mjs";
+import { surfaceGravity } from "./body.mjs";
+
+//#region src/physics/gravitation/variation.ts
+/**
+* How `g` changes with height, with depth, and with latitude.
+*
+* ── The one graph this file is trying to put in a learner's head ────────────────────────────────
+* `g` is a MAXIMUM AT THE SURFACE and falls off in both directions, but it falls off differently:
+*
+*     going up     g' = g·R²/(R+h)²      ≈ g(1 − 2h/R)   for small h
+*     going down   g' = g(1 − d/R)        exactly, for uniform density
+*
+* Read those two together and the whole shape follows. Near the surface, climbing loses you `g`
+* TWICE AS FAST as descending does, because above the surface the whole planet is still pulling and
+* only the distance grows, whereas below it the distance shrinks but the shell above you stops
+* counting. The depth law is a straight line to zero at the centre; the height law is a curve that
+* never reaches zero. Students who have only memorised the two formulas cannot draw that graph, and
+* the graph is what gets asked.
+*
+* ── Why `g` at the centre is zero, not infinite ─────────────────────────────────────────────────
+* The instinct is that gravity must be strongest at the centre, since that is what everything falls
+* towards. It is zero there: you are pulled equally in every direction. That follows from the shell
+* theorem (`potential.ts`), which says the mass in the shell ABOVE you contributes nothing at all,
+* so only the sphere below you counts, and at the centre there is no sphere below you.
+*
+* ── Latitude is a different kind of thing, and the difference matters ───────────────────────────
+* Height and depth genuinely change the gravitational FIELD. Latitude does not. The field at the
+* equator is very nearly what it is at the pole; what changes is that at the equator part of it is
+* spent supplying the centripetal acceleration of a body going round with the planet, so LESS IS
+* LEFT to press on a scale. `g` measured is an APPARENT weight, not the field.
+*
+* That is why the centripetal term is not reimplemented here: it is `rotation/circular.ts`'s, and a
+* learner who has met circular motion is meeting the same equation again, not a new one.
+*
+* Pure: no React, no pixels.
+*/
+const nonNegative = (value, what) => {
+	if (!Number.isFinite(value) || value < 0) throw new RangeError(`${what} must be zero or more, and finite`);
+	return value;
+};
+/**
+* `g` at a height above the surface: `g' = g·R²/(R+h)²`.
+*
+* Equivalently `mu/(R+h)²`, which is the same statement with the surface value never mentioned. The
+* error this guards against is using `h` where `R + h` belongs: at 400 km the International Space
+* Station has `g` of about 8.7 m/s², which is 89% of the surface value, NOT zero. Astronauts float
+* because they are falling, not because gravity has run out, and the number is how you prove it.
+*/
+const gravityAtHeight = (body, height) => body.mu / (body.radius + nonNegative(height, "height")) ** 2;
+/**
+* The same, worked, including the small-height approximation and where it stops being honest.
+*
+* `g' ≈ g(1 − 2h/R)` is the binomial expansion, and the FACTOR OF TWO in it is the thing to notice:
+* it is what makes climbing cost twice what descending costs. The working reports both the exact
+* value and the approximation so a learner can see the gap open up as `h` grows.
+*/
+function gravityAtHeightSteps(body, height, sf = 3) {
+	const h = nonNegative(height, "height");
+	const g = surfaceGravity(body);
+	const value = gravityAtHeight(body, h);
+	const approx = g * (1 - 2 * h / body.radius);
+	return calc().step("g' = \\frac{GM}{(R+h)^2}", "the distance from the CENTRE is R + h, never just h").step("g' = g\\left(\\frac{R}{R+h}\\right)^{2}", "divide by the surface value, and the mass and the constant both vanish").step(`g' = ${texSigFigs(g, sf)} \\times \\left(\\frac{${texSigFigs(body.radius, sf)}}{${texSigFigs(body.radius + h, sf)}}\\right)^{2} = ${texSigFigs(value, sf)}\\ \\mathrm{m\\,s^{-2}}`).step(`g' \\approx g\\left(1 - \\frac{2h}{R}\\right) = ${texSigFigs(approx, sf)}\\ \\mathrm{m\\,s^{-2}}`, h / body.radius < .05 ? "the binomial approximation, good here because h is small against R. Note the 2" : "the binomial approximation, which has broken down: h is no longer small against R").done(value);
+}
+/**
+* The height at which `g` has fallen to a given fraction of its surface value.
+*
+* `h = R(1/√f − 1)`. Half of `g` is at `h = 0.414R`, roughly 2600 km up, which is a useful shock: `g`
+* is still a quarter of its surface value out where the geostationary satellites are not, and
+* halving it takes you a third of the way to the Moon's distance in radii but nowhere near it.
+*/
+function heightForGravityFraction(body, fraction) {
+	if (!(fraction > 0 && fraction <= 1)) throw new RangeError("fraction must be in (0, 1]");
+	return body.radius * (1 / Math.sqrt(fraction) - 1);
+}
+/** The height at which `g` takes a given value, m. Throws if that value exceeds the surface value. */
+function heightForGravity(body, target) {
+	const g = surfaceGravity(body);
+	if (!(target > 0 && target <= g)) throw new RangeError("g above the surface can only fall, never rise");
+	return Math.sqrt(body.mu / target) - body.radius;
+}
+/**
+* `g` at a depth below the surface: `g' = g(1 − d/R)`, for a body of uniform density.
+*
+* A STRAIGHT LINE, reaching exactly zero at the centre, which is the half of the picture students
+* never draw. It follows from the shell theorem: the mass further out than you contributes nothing,
+* so only the sphere of radius `R − d` beneath you pulls, and its mass falls as the cube while the
+* distance falls as the square, leaving one power of the radius.
+*
+* "Uniform density" is a genuine idealisation and not a small one. The real Earth has a dense iron
+* core, so `g` actually RISES slightly on the way down and peaks near the core-mantle boundary at
+* around 10.7 m/s² before falling. Worth saying out loud in a lesson: the formula is exactly right
+* for the model and the model is not the Earth.
+*/
+function gravityAtDepth(body, depth) {
+	const d = nonNegative(depth, "depth");
+	if (d > body.radius) throw new RangeError("depth cannot exceed the radius");
+	return surfaceGravity(body) * (1 - d / body.radius);
+}
+/**
+* The height and the depth at which `g` has the same value, side by side.
+*
+* Built as one function because the question is always asked as a comparison, and the comparison is
+* the entire lesson: to lose a given fraction of `g` you must climb only about half as far as you
+* would have to dig. Returns both distances in metres plus the working that puts the factor of two
+* where a learner can see it.
+*/
+function equalGravityDepthAndHeight(body, fraction, sf = 3) {
+	if (!(fraction > 0 && fraction < 1)) throw new RangeError("fraction must be in (0, 1)");
+	const height = heightForGravityFraction(body, fraction);
+	const depth = body.radius * (1 - fraction);
+	return {
+		height,
+		depth,
+		worked: calc().step("g\\left(\\frac{R}{R+h}\\right)^{2} = g\\left(1 - \\frac{d}{R}\\right) = f g", "set both to the same fraction f of the surface value").step(`h = R\\left(\\tfrac{1}{\\sqrt{f}} - 1\\right) = ${texSigFigs(height, sf)}\\ \\mathrm{m}`).step(`d = R(1 - f) = ${texSigFigs(depth, sf)}\\ \\mathrm{m}`).step(`\\frac{d}{h} = ${texSigFigs(depth / height, sf)}`, "for small losses this tends to 2: climbing costs g twice as fast as digging does").done(height)
+	};
+}
+/**
+* Apparent `g` at a latitude on a rotating body: `g' = g − ω²R cos²λ`.
+*
+* The centripetal term comes from `rotation/circular.ts`, because it IS the centripetal
+* acceleration and a learner should recognise it rather than meet it as a new formula. The radius
+* of the circle a point actually travels is `R cos λ`, not `R`, which is where the cosine enters
+* and where the square comes from: one factor from the smaller circle, one from `ω²r`.
+*
+* At the pole the correction is exactly zero, because a point on the axis goes nowhere. At the
+* equator it is largest, at about 0.034 m/s², which is roughly 0.35% and is why `g` reads about 9.78
+* at the equator against 9.83 at the poles. The full 0.05 difference also includes the Earth's
+* equatorial bulge, which this does not model: a rotating planet is not a sphere, and the rotation
+* is the reason for both effects.
+*/
+function gravityAtLatitude(body, latitudeDeg) {
+	if (body.rotationPeriodS === void 0) return surfaceGravity(body);
+	const omega = 2 * Math.PI / body.rotationPeriodS;
+	const circleRadius = body.radius * Math.cos(toRadians(latitudeDeg));
+	const reduction = circleRadius === 0 ? 0 : centripetalAcceleration(omega * circleRadius, circleRadius) * Math.cos(toRadians(latitudeDeg));
+	return surfaceGravity(body) - reduction;
+}
+/**
+* How fast a body would have to spin for things at its equator to float free: `T = 2π√(R/g)`.
+*
+* The rotation at which the whole of `g` is used up supplying the centripetal requirement, so a
+* scale at the equator reads zero. For the Earth this is about 84 minutes, so the day would have to
+* shorten by a factor of roughly 17: that number is the answer to the textbook question, and it is
+* also the orbital period of a satellite skimming the surface, which is not a coincidence. Both ask
+* the same thing: what speed does gravity alone hold in a circle of radius `R`?
+*/
+function spinPeriodForWeightlessness(body, sf = 3) {
+	const g = surfaceGravity(body);
+	const value = 2 * Math.PI * Math.sqrt(body.radius / g);
+	return calc().step("mg = m\\omega^2 R", "weightless means gravity is entirely spent on going round, with nothing left for a scale").step("\\omega = \\sqrt{\\frac{g}{R}}", "the mass cancels, as it always does").step(`T = \\frac{2\\pi}{\\omega} = 2\\pi\\sqrt{\\frac{R}{g}} = 2\\pi\\sqrt{\\frac{${texSigFigs(body.radius, sf)}}{${texSigFigs(g, sf)}}}`).step(`T = ${texSigFigs(value, sf)}\\ \\mathrm{s}`, "which is also the period of a satellite skimming the surface. The same question, asked twice").done(value);
+}
+/**
+* Weight, m/s² times kg, at a stated place on or above a body.
+*
+* A convenience with a purpose: it forces the CHOICE of which variation applies to be named, rather
+* than a lesson silently using the surface value everywhere. Exactly one of `height`, `depth` or
+* `latitudeDeg` may be given.
+*/
+function weightAt(body, mass, place = {}) {
+	if ([
+		place.height,
+		place.depth,
+		place.latitudeDeg
+	].filter((v) => v !== void 0).length > 1) throw new RangeError("give at most one of height, depth or latitude");
+	if (place.height !== void 0) return mass * gravityAtHeight(body, place.height);
+	if (place.depth !== void 0) return mass * gravityAtDepth(body, place.depth);
+	if (place.latitudeDeg !== void 0) return mass * gravityAtLatitude(body, place.latitudeDeg);
+	return mass * surfaceGravity(body);
+}
+
+//#endregion
+export { equalGravityDepthAndHeight, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, spinPeriodForWeightlessness, weightAt };

package/dist/physics/index.d.mts

@@ -0,0 +1,35 @@
+import { ac_d_exports } from "./ac/index.mjs";
+import { coulomb_d_exports } from "./electrostatics/index.mjs";
+import { Components, DEG, Polar, Positive, SignConvention, compose, downPositive, resolve, resolveSteps, toDegrees, toRadians, upPositive } from "./vectors.mjs";
+import { Sweep, SweepMethod, SweepSample, SweepSpec, positionAtFraction, sweep } from "./integral-sweep.mjs";
+import { MOTION_EQUATIONS, MOTION_NAMES, MOTION_UNITS, MOTION_UNITS_TEX, MOTION_VARS, MotionEquation, MotionVar, equationWithout } from "./kinematics/equations.mjs";
+import { MotionGiven, chooseEquation } from "./kinematics/given.mjs";
+import { Root, TIME_EPSILON, classifyTime, preferredTime, speedRoots } from "./kinematics/roots.mjs";
+import { MotionSolution, motion, motionTable, timeToReach } from "./kinematics/solve.mjs";
+import { G_EARTH, VerticalMotion, describeSigns, dropped, vertical } from "./kinematics/free-fall.mjs";
+import { Flight, Launch, angleWhereRangeEqualsHeight, anglesForRange, arc, flight, flightSteps, launchVelocity, minimumSpeedForRange, peakSteps, positionAt, timeAtHeight, velocityAt } from "./projectile.mjs";
+import { Force, LiftResult, Resultant, accelerationForSupport, apparentWeight, force, forceXY, isBalanced, lami, resultant, resultantSteps, stringWithSideForce, weight } from "./dynamics/forces.mjs";
+import { AppliedForce, FrictionResult, FrictionSetup, angleOfFriction, angleOfRepose, degreesAndMinutes, frictionOn, pullVersusPush } from "./dynamics/friction.mjs";
+import { AtwoodResult, LinkedBody, SystemResult, atwood, linkedSystem } from "./dynamics/system.mjs";
+import { LiftWorkResult, MECHANICAL_KINDS, QuantityKind, WorkResult, WorkSign, angleFromWork, kindOf, signOfWork, slopeEnergyAudit, workAgainstGravity, workDone, workFromComponents, workFromPolar, workUpSlope } from "./energy/work.mjs";
+import { PotentialResult, elasticPE, gravitationalPE, gravitationalWork, kineticEnergy, kineticFromMomentum, kineticFromVelocity, momentumFromKinetic, speedFromKinetic } from "./energy/store.mjs";
+import { SpringLaunch, SpringWork, springCompressionToStop, springLaunch, springWork, stiffnessForEnergyRatio } from "./energy/spring.mjs";
+import { PenetrationResult, WorkEnergyResult, resistanceFromDrop, resistanceFromStrike, speedToPenetrate, stoppingDistance, workEnergy, workToStop } from "./energy/theorem.mjs";
+import { Ladder, Rung, Station, SwingResult, dropForKinetic, energyLadder, heightWherePotentialIs, pendulumSwing, releaseAngleForSpeed, speedAfterDrop } from "./energy/conservation.mjs";
+import { EfficiencyResult, HORSEPOWER, HORSEPOWER_METRIC, LiftingPower, chainEfficiency, efficiency, hoistPower, massRaisedInTime, power, powerFromForceSpeed, pumpPower, speedFromPower, toHorsepower, usefulOutput } from "./energy/power.mjs";
+import { DrainResult, StackResult, centreOfMassLift, chainLift, columnDrain, meanLiftToRim, stackColumn, standBlockOnEnd, tiltRod } from "./energy/centre-of-mass.mjs";
+import { ImpulseResult, VariableImpulse, bounceOffWall, forceForContact, impulseOf, impulseToChange, rocketAcceleration, rocketThrust } from "./momentum/impulse.mjs";
+import { CollisionInput, CollisionOutcome, collide, restitutionFromBounce, restitutionOf, separateFrom } from "./momentum/collide.mjs";
+import { PlanarBody, PlanarSolution, conserveMomentum, momentumAsComplex, momentumIsConserved, momentumOf, totalMomentum } from "./momentum/planar.mjs";
+import { InertiaResult, SHAPES, ShapeGeometry, ShapeSpec, combine, distanceFromAxis, inertiaComesFrom, momentOfInertia, parallelAxis, perpendicularAxis, pointMasses, radiusOfGyration, shapeIds, sweepOf } from "./rotation/inertia.mjs";
+import { ROTATIONAL_ANALOGUE, angularAcceleration, balancingCouple, couple, torque, torqueFromRate } from "./rotation/torque.mjs";
+import { ROLLING_SHAPES, RollingEnergy, RollingShape, SpinChange, angularMomentum, angularMomentumOfPoint, conserveSpin, fromRPM, fromRevsPerSecond, rollingEnergy, rollingRace, rollingSpeedFromHeight } from "./rotation/angular.mjs";
+import { bankingAngle, centripetalAcceleration, centripetalForce, centripetalFromOmega, maxSpeedBanked, maxSpeedFlat, minimumSpeedAtTop, railCant, verticalCircleTension } from "./rotation/circular.mjs";
+import { CentralBody, EARTH, EARTH_MOON_DISTANCE, EARTH_SUN_DISTANCE, JUPITER, MARS, MOON, SUN, bodyFromDensity, bodyFromMass, bodyFromSurfaceGravity, bodyVolume, meanDensity, surfaceGravity, surfaceGravityFromDensity, surfaceGravityRatio } from "./gravitation/body.mjs";
+import { GravitySource, NetGravity, gravitationalForce, gravitationalForceSteps, inverseSquareFactor, netGravitationalForce, nullPoint, rocheLimit, tidalAcceleration, tideRatio } from "./gravitation/law.mjs";
+import { equalGravityDepthAndHeight, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, spinPeriodForWeightlessness, weightAt } from "./gravitation/variation.mjs";
+import { ShellRegion, escapeSpeed, escapeSpeedSteps, gravitationalFieldStrength, gravitationalPotential, gravitationalPotentialEnergy, potentialDifference, riseHeight, shellFieldAndPotential, sphereFieldAndPotential, sphereSelfEnergy } from "./gravitation/potential.mjs";
+import { OrbitalEnergy, TrajectoryKind, geostationaryOrbit, hohmannTransfer, orbitRadiusForPeriod, orbitalEnergy, orbitalEnergySteps, orbitalPeriod, orbitalSpeed, orbitalSpeedSteps, surfaceSkimmingOrbit, trajectoryKind, visViva } from "./gravitation/orbit.mjs";
+import { OrbitPoint, apsides, apsisSpeeds, arealVelocity, axisFromPeriod, centralMassFromOrbit, keplerRatio, orbitFromApsides, orbitPointAtMeanAnomaly, orbitPointAtTime, periodFromAxis, semiMinorAxis, solveEccentricAnomaly, specificAngularMomentum, synodicPeriod } from "./gravitation/kepler.mjs";
+import { index_d_exports } from "./magnetism/index.mjs";
+export { type AppliedForce, type AtwoodResult, CentralBody, type CollisionInput, type CollisionOutcome, Components, DEG, DrainResult, EARTH, EARTH_MOON_DISTANCE, EARTH_SUN_DISTANCE, EfficiencyResult, Flight, type Force, type FrictionResult, type FrictionSetup, G_EARTH, GravitySource, HORSEPOWER, HORSEPOWER_METRIC, type ImpulseResult, type InertiaResult, JUPITER, Ladder, Launch, type LiftResult, LiftWorkResult, LiftingPower, type LinkedBody, MARS, MECHANICAL_KINDS, MOON, MOTION_EQUATIONS, MOTION_NAMES, MOTION_UNITS, MOTION_UNITS_TEX, MOTION_VARS, type MotionEquation, type MotionGiven, type MotionSolution, type MotionVar, NetGravity, OrbitPoint, OrbitalEnergy, PenetrationResult, type PlanarBody, type PlanarSolution, Polar, Positive, PotentialResult, QuantityKind, ROLLING_SHAPES, ROTATIONAL_ANALOGUE, type Resultant, type RollingEnergy, type RollingShape, type Root, Rung, SHAPES, SUN, type ShapeGeometry, type ShapeSpec, ShellRegion, SignConvention, type SpinChange, SpringLaunch, SpringWork, StackResult, Station, Sweep, SweepMethod, SweepSample, SweepSpec, SwingResult, type SystemResult, TIME_EPSILON, TrajectoryKind, type VariableImpulse, type VerticalMotion, WorkEnergyResult, WorkResult, WorkSign, ac_d_exports as ac, accelerationForSupport, angleFromWork, angleOfFriction, angleOfRepose, angleWhereRangeEqualsHeight, anglesForRange, angularAcceleration, angularMomentum, angularMomentumOfPoint, apparentWeight, apsides, apsisSpeeds, arc, arealVelocity, atwood, axisFromPeriod, balancingCouple, bankingAngle, bodyFromDensity, bodyFromMass, bodyFromSurfaceGravity, bodyVolume, bounceOffWall, centralMassFromOrbit, centreOfMassLift, centripetalAcceleration, centripetalForce, centripetalFromOmega, chainEfficiency, chainLift, chooseEquation, classifyTime, collide, columnDrain, combine, compose, conserveMomentum, conserveSpin, couple, degreesAndMinutes, describeSigns, distanceFromAxis, downPositive, dropForKinetic, dropped, efficiency, elasticPE, coulomb_d_exports as electrostatics, energyLadder, equalGravityDepthAndHeight, equationWithout, escapeSpeed, escapeSpeedSteps, flight, flightSteps, force, forceForContact, forceXY, frictionOn, fromRPM, fromRevsPerSecond, geostationaryOrbit, gravitationalFieldStrength, gravitationalForce, gravitationalForceSteps, gravitationalPE, gravitationalPotential, gravitationalPotentialEnergy, gravitationalWork, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, heightWherePotentialIs, hohmannTransfer, hoistPower, impulseOf, impulseToChange, inertiaComesFrom, inverseSquareFactor, isBalanced, keplerRatio, kindOf, kineticEnergy, kineticFromMomentum, kineticFromVelocity, lami, launchVelocity, linkedSystem, index_d_exports as magnetism, massRaisedInTime, maxSpeedBanked, maxSpeedFlat, meanDensity, meanLiftToRim, minimumSpeedAtTop, minimumSpeedForRange, momentOfInertia, momentumAsComplex, momentumFromKinetic, momentumIsConserved, momentumOf, motion, motionTable, netGravitationalForce, nullPoint, orbitFromApsides, orbitPointAtMeanAnomaly, orbitPointAtTime, orbitRadiusForPeriod, orbitalEnergy, orbitalEnergySteps, orbitalPeriod, orbitalSpeed, orbitalSpeedSteps, parallelAxis, peakSteps, pendulumSwing, periodFromAxis, perpendicularAxis, pointMasses, positionAt, positionAtFraction, potentialDifference, power, powerFromForceSpeed, preferredTime, pullVersusPush, pumpPower, radiusOfGyration, railCant, releaseAngleForSpeed, resistanceFromDrop, resistanceFromStrike, resolve, resolveSteps, restitutionFromBounce, restitutionOf, resultant, resultantSteps, riseHeight, rocheLimit, rocketAcceleration, rocketThrust, rollingEnergy, rollingRace, rollingSpeedFromHeight, semiMinorAxis, separateFrom, shapeIds, shellFieldAndPotential, signOfWork, slopeEnergyAudit, solveEccentricAnomaly, specificAngularMomentum, speedAfterDrop, speedFromKinetic, speedFromPower, speedRoots, speedToPenetrate, sphereFieldAndPotential, sphereSelfEnergy, spinPeriodForWeightlessness, springCompressionToStop, springLaunch, springWork, stackColumn, standBlockOnEnd, stiffnessForEnergyRatio, stoppingDistance, stringWithSideForce, surfaceGravity, surfaceGravityFromDensity, surfaceGravityRatio, surfaceSkimmingOrbit, sweep, sweepOf, synodicPeriod, tidalAcceleration, tideRatio, tiltRod, timeAtHeight, timeToReach, toDegrees, toHorsepower, toRadians, torque, torqueFromRate, totalMomentum, trajectoryKind, upPositive, usefulOutput, velocityAt, vertical, verticalCircleTension, visViva, weight, weightAt, workAgainstGravity, workDone, workEnergy, workFromComponents, workFromPolar, workToStop, workUpSlope };

package/dist/physics/index.mjs

@@ -0,0 +1,36 @@
+import { magnetism_exports } from "./magnetism/index.mjs";
+import { DEG, SignConvention, compose, downPositive, resolve, resolveSteps, toDegrees, toRadians, upPositive } from "./vectors.mjs";
+import { G_EARTH, describeSigns, dropped, vertical } from "./kinematics/free-fall.mjs";
+import { accelerationForSupport, apparentWeight, force, forceXY, isBalanced, lami, resultant, resultantSteps, stringWithSideForce, weight } from "./dynamics/forces.mjs";
+import { coulomb_exports } from "./electrostatics/index.mjs";
+import { ac_exports } from "./ac/index.mjs";
+import { positionAtFraction, sweep } from "./integral-sweep.mjs";
+import { MOTION_EQUATIONS, MOTION_NAMES, MOTION_UNITS, MOTION_UNITS_TEX, MOTION_VARS, equationWithout } from "./kinematics/equations.mjs";
+import { chooseEquation } from "./kinematics/given.mjs";
+import { TIME_EPSILON, classifyTime, preferredTime, speedRoots } from "./kinematics/roots.mjs";
+import { motion, motionTable, timeToReach } from "./kinematics/solve.mjs";
+import { angleWhereRangeEqualsHeight, anglesForRange, arc, flight, flightSteps, launchVelocity, minimumSpeedForRange, peakSteps, positionAt, timeAtHeight, velocityAt } from "./projectile.mjs";
+import { angleOfFriction, angleOfRepose, degreesAndMinutes, frictionOn, pullVersusPush } from "./dynamics/friction.mjs";
+import { atwood, linkedSystem } from "./dynamics/system.mjs";
+import { MECHANICAL_KINDS, angleFromWork, kindOf, signOfWork, slopeEnergyAudit, workAgainstGravity, workDone, workFromComponents, workFromPolar, workUpSlope } from "./energy/work.mjs";
+import { elasticPE, gravitationalPE, gravitationalWork, kineticEnergy, kineticFromMomentum, kineticFromVelocity, momentumFromKinetic, speedFromKinetic } from "./energy/store.mjs";
+import { springCompressionToStop, springLaunch, springWork, stiffnessForEnergyRatio } from "./energy/spring.mjs";
+import { resistanceFromDrop, resistanceFromStrike, speedToPenetrate, stoppingDistance, workEnergy, workToStop } from "./energy/theorem.mjs";
+import { dropForKinetic, energyLadder, heightWherePotentialIs, pendulumSwing, releaseAngleForSpeed, speedAfterDrop } from "./energy/conservation.mjs";
+import { HORSEPOWER, HORSEPOWER_METRIC, chainEfficiency, efficiency, hoistPower, massRaisedInTime, power, powerFromForceSpeed, pumpPower, speedFromPower, toHorsepower, usefulOutput } from "./energy/power.mjs";
+import { centreOfMassLift, chainLift, columnDrain, meanLiftToRim, stackColumn, standBlockOnEnd, tiltRod } from "./energy/centre-of-mass.mjs";
+import { bounceOffWall, forceForContact, impulseOf, impulseToChange, rocketAcceleration, rocketThrust } from "./momentum/impulse.mjs";
+import { collide, restitutionFromBounce, restitutionOf, separateFrom } from "./momentum/collide.mjs";
+import { conserveMomentum, momentumAsComplex, momentumIsConserved, momentumOf, totalMomentum } from "./momentum/planar.mjs";
+import { SHAPES, combine, distanceFromAxis, inertiaComesFrom, momentOfInertia, parallelAxis, perpendicularAxis, pointMasses, radiusOfGyration, shapeIds, sweepOf } from "./rotation/inertia.mjs";
+import { ROTATIONAL_ANALOGUE, angularAcceleration, balancingCouple, couple, torque, torqueFromRate } from "./rotation/torque.mjs";
+import { ROLLING_SHAPES, angularMomentum, angularMomentumOfPoint, conserveSpin, fromRPM, fromRevsPerSecond, rollingEnergy, rollingRace, rollingSpeedFromHeight } from "./rotation/angular.mjs";
+import { bankingAngle, centripetalAcceleration, centripetalForce, centripetalFromOmega, maxSpeedBanked, maxSpeedFlat, minimumSpeedAtTop, railCant, verticalCircleTension } from "./rotation/circular.mjs";
+import { EARTH, EARTH_MOON_DISTANCE, EARTH_SUN_DISTANCE, JUPITER, MARS, MOON, SUN, bodyFromDensity, bodyFromMass, bodyFromSurfaceGravity, bodyVolume, meanDensity, surfaceGravity, surfaceGravityFromDensity, surfaceGravityRatio } from "./gravitation/body.mjs";
+import { gravitationalForce, gravitationalForceSteps, inverseSquareFactor, netGravitationalForce, nullPoint, rocheLimit, tidalAcceleration, tideRatio } from "./gravitation/law.mjs";
+import { equalGravityDepthAndHeight, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, spinPeriodForWeightlessness, weightAt } from "./gravitation/variation.mjs";
+import { escapeSpeed, escapeSpeedSteps, gravitationalFieldStrength, gravitationalPotential, gravitationalPotentialEnergy, potentialDifference, riseHeight, shellFieldAndPotential, sphereFieldAndPotential, sphereSelfEnergy } from "./gravitation/potential.mjs";
+import { geostationaryOrbit, hohmannTransfer, orbitRadiusForPeriod, orbitalEnergy, orbitalEnergySteps, orbitalPeriod, orbitalSpeed, orbitalSpeedSteps, surfaceSkimmingOrbit, trajectoryKind, visViva } from "./gravitation/orbit.mjs";
+import { apsides, apsisSpeeds, arealVelocity, axisFromPeriod, centralMassFromOrbit, keplerRatio, orbitFromApsides, orbitPointAtMeanAnomaly, orbitPointAtTime, periodFromAxis, semiMinorAxis, solveEccentricAnomaly, specificAngularMomentum, synodicPeriod } from "./gravitation/kepler.mjs";
+
+export { DEG, EARTH, EARTH_MOON_DISTANCE, EARTH_SUN_DISTANCE, G_EARTH, HORSEPOWER, HORSEPOWER_METRIC, JUPITER, MARS, MECHANICAL_KINDS, MOON, MOTION_EQUATIONS, MOTION_NAMES, MOTION_UNITS, MOTION_UNITS_TEX, MOTION_VARS, ROLLING_SHAPES, ROTATIONAL_ANALOGUE, SHAPES, SUN, SignConvention, TIME_EPSILON, ac_exports as ac, accelerationForSupport, angleFromWork, angleOfFriction, angleOfRepose, angleWhereRangeEqualsHeight, anglesForRange, angularAcceleration, angularMomentum, angularMomentumOfPoint, apparentWeight, apsides, apsisSpeeds, arc, arealVelocity, atwood, axisFromPeriod, balancingCouple, bankingAngle, bodyFromDensity, bodyFromMass, bodyFromSurfaceGravity, bodyVolume, bounceOffWall, centralMassFromOrbit, centreOfMassLift, centripetalAcceleration, centripetalForce, centripetalFromOmega, chainEfficiency, chainLift, chooseEquation, classifyTime, collide, columnDrain, combine, compose, conserveMomentum, conserveSpin, couple, degreesAndMinutes, describeSigns, distanceFromAxis, downPositive, dropForKinetic, dropped, efficiency, elasticPE, coulomb_exports as electrostatics, energyLadder, equalGravityDepthAndHeight, equationWithout, escapeSpeed, escapeSpeedSteps, flight, flightSteps, force, forceForContact, forceXY, frictionOn, fromRPM, fromRevsPerSecond, geostationaryOrbit, gravitationalFieldStrength, gravitationalForce, gravitationalForceSteps, gravitationalPE, gravitationalPotential, gravitationalPotentialEnergy, gravitationalWork, gravityAtDepth, gravityAtHeight, gravityAtHeightSteps, gravityAtLatitude, heightForGravity, heightForGravityFraction, heightWherePotentialIs, hohmannTransfer, hoistPower, impulseOf, impulseToChange, inertiaComesFrom, inverseSquareFactor, isBalanced, keplerRatio, kindOf, kineticEnergy, kineticFromMomentum, kineticFromVelocity, lami, launchVelocity, linkedSystem, magnetism_exports as magnetism, massRaisedInTime, maxSpeedBanked, maxSpeedFlat, meanDensity, meanLiftToRim, minimumSpeedAtTop, minimumSpeedForRange, momentOfInertia, momentumAsComplex, momentumFromKinetic, momentumIsConserved, momentumOf, motion, motionTable, netGravitationalForce, nullPoint, orbitFromApsides, orbitPointAtMeanAnomaly, orbitPointAtTime, orbitRadiusForPeriod, orbitalEnergy, orbitalEnergySteps, orbitalPeriod, orbitalSpeed, orbitalSpeedSteps, parallelAxis, peakSteps, pendulumSwing, periodFromAxis, perpendicularAxis, pointMasses, positionAt, positionAtFraction, potentialDifference, power, powerFromForceSpeed, preferredTime, pullVersusPush, pumpPower, radiusOfGyration, railCant, releaseAngleForSpeed, resistanceFromDrop, resistanceFromStrike, resolve, resolveSteps, restitutionFromBounce, restitutionOf, resultant, resultantSteps, riseHeight, rocheLimit, rocketAcceleration, rocketThrust, rollingEnergy, rollingRace, rollingSpeedFromHeight, semiMinorAxis, separateFrom, shapeIds, shellFieldAndPotential, signOfWork, slopeEnergyAudit, solveEccentricAnomaly, specificAngularMomentum, speedAfterDrop, speedFromKinetic, speedFromPower, speedRoots, speedToPenetrate, sphereFieldAndPotential, sphereSelfEnergy, spinPeriodForWeightlessness, springCompressionToStop, springLaunch, springWork, stackColumn, standBlockOnEnd, stiffnessForEnergyRatio, stoppingDistance, stringWithSideForce, surfaceGravity, surfaceGravityFromDensity, surfaceGravityRatio, surfaceSkimmingOrbit, sweep, sweepOf, synodicPeriod, tidalAcceleration, tideRatio, tiltRod, timeAtHeight, timeToReach, toDegrees, toHorsepower, toRadians, torque, torqueFromRate, totalMomentum, trajectoryKind, upPositive, usefulOutput, velocityAt, vertical, verticalCircleTension, visViva, weight, weightAt, workAgainstGravity, workDone, workEnergy, workFromComponents, workFromPolar, workToStop, workUpSlope };

package/dist/physics/integral-sweep.d.mts

@@ -0,0 +1,63 @@
+import { Node } from "../math/ast.mjs";
+
+//#region src/physics/integral-sweep.d.ts
+interface SweepSpec {
+  /** The integrand, as an expression in `variable`. Must be an expanded polynomial. */
+  readonly element: string;
+  readonly variable: string;
+  /** Limits, as expressions in the symbols. */
+  readonly from: string;
+  readonly to: string;
+}
+/** One frame of the sweep. */
+interface SweepSample {
+  /** Where the element is: the value of the integration variable. */
+  readonly at: number;
+  /** How much THIS element contributes per unit of the variable: the integrand's value. */
+  readonly density: number;
+  /** The integral so far, from the lower limit up to `at`. */
+  readonly accumulated: number;
+  /** `accumulated` as a fraction of the whole, for a progress meter. 0 to 1. */
+  readonly fraction: number;
+}
+/**
+ * How the integral was done.
+ *
+ * Reported rather than hidden, because it changes what may honestly be shown. A `symbolic` sweep
+ * can print a closed form and an exact answer; a `numeric` one can print a number and a graph and
+ * must not claim a formula it does not have.
+ */
+type SweepMethod = 'symbolic' | 'numeric';
+interface Sweep {
+  readonly samples: readonly SweepSample[];
+  /** The completed integral. The last sample's `accumulated` equals this exactly. */
+  readonly total: number;
+  readonly lower: number;
+  readonly upper: number;
+  readonly method: SweepMethod;
+  /**
+   * The symbolic antiderivative, for whatever prints the derivation. Null when the integrand was
+   * beyond the symbolic engine and the values came from quadrature instead.
+   */
+  readonly antiderivative: Node | null;
+}
+/**
+ * Sample the running value of an integral across its range.
+ *
+ * ```ts
+ * // Why a ring beats a disc: watch where the contribution actually comes from.
+ * sweep({ element: '(2*M/R^2)*r^3', variable: 'r', from: '0', to: 'R' }, { M: 1, R: 1 });
+ * // half the total arrives in the last 16% of the radius
+ * ```
+ */
+declare function sweep(spec: SweepSpec, values: Readonly<Record<string, number>>, samples?: number): Sweep;
+/**
+ * Where the value actually comes from: the position by which a given fraction has accumulated.
+ *
+ * This is the number that makes the r² weighting vivid. For a uniform disc, half the moment of
+ * inertia lives beyond 84% of the radius, and a learner who has seen that will never again wonder
+ * why a flywheel puts its mass at the rim.
+ */
+declare function positionAtFraction(s: Sweep, fraction: number): number;
+//#endregion
+export { Sweep, SweepMethod, SweepSample, SweepSpec, positionAtFraction, sweep };

package/dist/physics/integral-sweep.mjs

@@ -0,0 +1,126 @@
+import { evaluate } from "../math/ast.mjs";
+import { parse } from "../math/parse.mjs";
+import { integrate } from "../math/calculus.mjs";
+import { quadrature } from "../math/analysis.mjs";
+
+//#region src/physics/integral-sweep.ts
+/**
+* An integral you can watch happen.
+*
+* A definite integral is taught as a procedure and drawn, if at all, as a static picture of shaded
+* strips. The thing that actually makes it click is motion: one element sweeping through the body
+* while a running total fills, so you SEE that the far elements count for more and the near ones
+* count for almost nothing. After that, `∫r² dm` is not a formula, it is a description of something
+* you watched.
+*
+* This module produces the data for that, for ANY integral, not just moments of inertia:
+*
+*   - `work = ∫F dx` for a variable force, where the strips are the force-distance graph;
+*   - `I = ∫r² dm`, where the r² weighting is the point being made;
+*   - centre of mass, `x̄ = (1/M)∫x dm`;
+*   - charge on a non-uniform rod, and the rest of the university-level list.
+*
+* It is deliberately NOT about rotation, and lives one level up from it, because the visual is the
+* reusable thing. A renderer that can animate one of these can animate all of them.
+*
+* The integral is done SYMBOLICALLY once and then evaluated at each sample, rather than summed
+* numerically. That matters for honesty: the running total is the real antiderivative, so the
+* animation and the printed derivation are the same mathematics, and the final frame lands exactly
+* on the closed-form answer instead of near it.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* Sample the running value of an integral across its range.
+*
+* ```ts
+* // Why a ring beats a disc: watch where the contribution actually comes from.
+* sweep({ element: '(2*M/R^2)*r^3', variable: 'r', from: '0', to: 'R' }, { M: 1, R: 1 });
+* // half the total arrives in the last 16% of the radius
+* ```
+*/
+function sweep(spec, values, samples = 64) {
+	if (samples < 2) throw new Error("A sweep needs at least two samples to show anything.");
+	const element = parse(spec.element);
+	const lower = evaluate(parse(spec.from), values);
+	const upper = evaluate(parse(spec.to), values);
+	const density = (point) => evaluate(element, {
+		...values,
+		[spec.variable]: point
+	});
+	/**
+	* Symbolic when we can, quadrature when we cannot, and never a refusal.
+	*
+	* This is the whole reason the engine is usable beyond a syllabus. A rod whose density varies as
+	* `sin`, a sphere with a `1/(1+r²)` profile, or anything else a university problem invents has no
+	* closed form in our table, and returning nothing would mean the lab simply stops working on the
+	* interesting cases. Simpson's rule is accurate to near machine precision on a smooth integrand,
+	* so the picture and the number are right; only the CLOSED FORM is unavailable, and `method` says
+	* so, so nothing downstream claims otherwise.
+	*/
+	const antiderivative = integrate(element, spec.variable);
+	const method = antiderivative ? "symbolic" : "numeric";
+	const positions = Array.from({ length: samples }, (_, i) => lower + (upper - lower) * i / (samples - 1));
+	/**
+	* The running value at each sample.
+	*
+	* Symbolically this is one evaluation per sample. Numerically it is the panel between each pair
+	* of samples, ADDED to the running total, rather than a fresh integration from the lower limit
+	* every time. The first version did the latter, at Simpson's default 1000 subdivisions, so a
+	* 512-sample sweep performed half a million evaluations and took 26 ms: past a frame budget for
+	* something whose entire purpose is to be animated. Panels are short, so a handful of
+	* subdivisions each is more than enough accuracy, and the work drops by about a hundredfold.
+	*/
+	const PANEL_STEPS = 8;
+	const accumulated = new Array(samples);
+	if (antiderivative) {
+		const at = (p) => evaluate(antiderivative, {
+			...values,
+			[spec.variable]: p
+		});
+		const base = at(lower);
+		for (let i = 0; i < samples; i++) accumulated[i] = at(positions[i]) - base;
+	} else {
+		accumulated[0] = 0;
+		for (let i = 1; i < samples; i++) accumulated[i] = accumulated[i - 1] + quadrature(density, positions[i - 1], positions[i], PANEL_STEPS);
+	}
+	const total = accumulated[samples - 1];
+	return {
+		samples: positions.map((position, i) => ({
+			at: position,
+			density: density(position),
+			accumulated: accumulated[i],
+			fraction: total === 0 ? 0 : accumulated[i] / total
+		})),
+		total,
+		lower,
+		upper,
+		method,
+		antiderivative
+	};
+}
+/**
+* Where the value actually comes from: the position by which a given fraction has accumulated.
+*
+* This is the number that makes the r² weighting vivid. For a uniform disc, half the moment of
+* inertia lives beyond 84% of the radius, and a learner who has seen that will never again wonder
+* why a flywheel puts its mass at the rim.
+*/
+function positionAtFraction(s, fraction) {
+	if (fraction <= 0) return s.lower;
+	if (fraction >= 1) return s.upper;
+	let previous = s.samples[0];
+	for (const sample of s.samples) {
+		if (sample.fraction >= fraction) {
+			const span = sample.fraction - previous.fraction;
+			if (span <= 0) return sample.at;
+			const t = (fraction - previous.fraction) / span;
+			return previous.at + t * (sample.at - previous.at);
+		}
+		previous = sample;
+	}
+	return s.upper;
+}
+
+//#endregion
+export { positionAtFraction, sweep };

package/dist/physics/kinematics/equations.d.mts

@@ -0,0 +1,47 @@
+import { Relation } from "../../relation/index.mjs";
+
+//#region src/physics/kinematics/equations.d.ts
+/** The five quantities of straight-line motion at constant acceleration. */
+type MotionVar = 'u' | 'v' | 'a' | 's' | 't';
+declare const MOTION_VARS: readonly MotionVar[];
+/** What each symbol means, for a lesson that lists them and for error messages that name them. */
+declare const MOTION_NAMES: Readonly<Record<MotionVar, string>>;
+/**
+ * The unit each quantity is held in, spelled for the UNIT PARSER.
+ *
+ * These strings are machine input, not display text. `m/s^2` is how `parseUnit` reads metres per
+ * second squared; it is not how a physics paper prints it, and putting it on screen is how a
+ * derivation ends up with a stray caret in it.
+ */
+declare const MOTION_UNITS: Readonly<Record<MotionVar, string>>;
+/**
+ * The same units spelled for DISPLAY, as LaTeX.
+ *
+ * Index notation (`m s⁻²`) rather than a solidus, because that is the convention in every physics
+ * paper these students will sit, and upright roman rather than italic, because an italic `m` is a
+ * variable and an upright one is metres. The thin space between the symbols is not decoration: it
+ * is what distinguishes `m s` (metre-seconds) from `ms` (milliseconds).
+ */
+declare const MOTION_UNITS_TEX: Readonly<Record<MotionVar, string>>;
+/** One SUVAT equation, and the single quantity it does not mention. */
+interface MotionEquation {
+  readonly id: string;
+  readonly relation: Relation;
+  /** The variable absent from this equation. This is what makes the equation choosable. */
+  readonly omits: MotionVar;
+  /** True when the equation is quadratic in `t`, so solving it for `t` is not an isolation. */
+  readonly quadraticInTime: boolean;
+}
+/**
+ * The five equations.
+ *
+ * `s = vt − ½at²` is the one most textbooks omit, and then they have to fudge every question that
+ * gives the FINAL velocity and asks for the displacement. It is included for the same reason the
+ * other four are: leaving it out would mean one of the five choices has no equation behind it, and
+ * the method would stop being reliable exactly once per chapter.
+ */
+declare const MOTION_EQUATIONS: readonly MotionEquation[];
+/** The equation that leaves out a given quantity. Exactly one does, which is the whole method. */
+declare const equationWithout: (omitted: MotionVar) => MotionEquation | undefined;
+//#endregion
+export { MOTION_EQUATIONS, MOTION_NAMES, MOTION_UNITS, MOTION_UNITS_TEX, MOTION_VARS, MotionEquation, MotionVar, equationWithout };