@interstellar-tools/equations 1.3.0 → 1.5.0

package/dist/categories/entry/ballistic-peak-deceleration-altitude.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Compute the **altitude of peak deceleration** in a ballistic entry, with the Allen–Eggers solution.
+ *
+ * $$
+ * h^\ast = H \ln\frac{\rho_0 H}{\beta \sin\lvert\gamma\rvert}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**, `H` in **m**.
+ * - Output: $ h^\ast $ in **m**.
+ *
+ * ::: info Notes
+ *
+ * - Unlike the size of the peak ({@link ballisticPeakDeceleration}), its altitude does depend on the vehicle: a higher $ \beta $ peaks lower down.
+ * - A negative result means the vehicle would reach the surface before its deceleration peaks: it hits the ground still fast.
+ * - Same assumptions as {@link ballisticEntrySpeed}.
+ *
+ * :::
+ *
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Altitude of peak deceleration $ h^\ast $ in **m** (negative if below the surface).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule, 6.5° below horizontal, in Earth's atmosphere
+ * const h = ballisticPeakDecelerationAltitude((-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // h ≈ 39.5 km
+ * ```
+ *
+ * @see {@link ballisticPeakDeceleration}
+ * @see {@link ballisticEntrySpeed}
+ */
+export declare const ballisticPeakDecelerationAltitude: (gamma: number, beta: number, rho0: number, H: number) => number;
+//# sourceMappingURL=ballistic-peak-deceleration-altitude.d.ts.map

package/dist/categories/entry/ballistic-peak-deceleration-altitude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration-altitude.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration-altitude.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,iCAAiC,GAC5C,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,MAAM,MAAM,EACZ,GAAG,MAAM,KACR,MAeF,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration-altitude.js

@@ -0,0 +1,62 @@
+import { assertFinite, assertFlightPathAngle, assertPositive } from './validate.js';
+/**
+ * Compute the **altitude of peak deceleration** in a ballistic entry, with the Allen–Eggers solution.
+ *
+ * $$
+ * h^\ast = H \ln\frac{\rho_0 H}{\beta \sin\lvert\gamma\rvert}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the ballistic coefficient (kg/m²)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ \rho_0 $ and $ H $ describe an exponential atmosphere, $ \rho = \rho_0 e^{-h/H} $
+ *
+ * **Units**
+ * - Inputs: `gamma` in **radians**, `beta` in **kg/m²**, `rho0` in **kg/m³**, `H` in **m**.
+ * - Output: $ h^\ast $ in **m**.
+ *
+ * ::: info Notes
+ *
+ * - Unlike the size of the peak ({@link ballisticPeakDeceleration}), its altitude does depend on the vehicle: a higher $ \beta $ peaks lower down.
+ * - A negative result means the vehicle would reach the surface before its deceleration peaks: it hits the ground still fast.
+ * - Same assumptions as {@link ballisticEntrySpeed}.
+ *
+ * :::
+ *
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param beta - Ballistic coefficient $ \beta $ in **kg/m²** (finite, > 0).
+ * @param rho0 - Reference density $ \rho_0 $ in **kg/m³** (finite, > 0).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Altitude of peak deceleration $ h^\ast $ in **m** (negative if below the surface).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `beta`, `rho0` or `H` is `<= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 322 kg/m² capsule, 6.5° below horizontal, in Earth's atmosphere
+ * const h = ballisticPeakDecelerationAltitude((-6.5 * Math.PI / 180) as Radians, 322, 1.225, 7200);
+ * // h ≈ 39.5 km
+ * ```
+ *
+ * @see {@link ballisticPeakDeceleration}
+ * @see {@link ballisticEntrySpeed}
+ */
+export const ballisticPeakDecelerationAltitude = (gamma, beta, rho0, H) => {
+    assertFinite([
+        ['gamma', gamma],
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertPositive([
+        ['beta', beta],
+        ['rho0', rho0],
+        ['H', H]
+    ]);
+    assertFlightPathAngle(gamma);
+    return H * Math.log((rho0 * H) / (beta * Math.sin(Math.abs(gamma))));
+};
+//# sourceMappingURL=ballistic-peak-deceleration-altitude.js.map

package/dist/categories/entry/ballistic-peak-deceleration-altitude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration-altitude.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration-altitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,KAAa,EACb,IAAY,EACZ,IAAY,EACZ,CAAS,EACD,EAAE;IACV,YAAY,CAAC;QACX,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,cAAc,CAAC;QACb,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAE7B,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Compute the **peak deceleration of a ballistic entry**, with the Allen–Eggers solution.
+ *
+ * $$
+ * a_\text{max} = \frac{V_E^2 \sin\lvert\gamma\rvert}{2\,e\,H}
+ * $$
+ *
+ * reached when the speed has fallen to $ V_E / \sqrt{e} \approx 0.61\,V_E $.
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ H $ is the atmosphere's scale height (m)
+ * - $ e $ is Euler's number
+ *
+ * **Units**
+ * - Inputs: `VE` in **m/s**, `gamma` in **radians**, `H` in **m**.
+ * - Output: $ a_\text{max} $ in **m/s²**. Divide by 9.80665 for g.
+ *
+ * ::: info Notes
+ *
+ * - The peak doesn't depend on the vehicle's mass, size or drag: a heavier one just reaches it lower down. Only the entry speed and angle matter.
+ * - It grows with $ \sin\lvert\gamma\rvert $: a steeper entry is a harder one.
+ * - Same assumptions as {@link ballisticEntrySpeed}: no lift, no gravity, a straight path. A lifting entry spreads the deceleration out and peaks much lower.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, coming home
+ *
+ * **35.8 g**
+ *
+ * _A ballistic entry at 11.03 km/s and −6.48°, with H = 7.2 km_
+ *
+ * The crew felt 6.56 g at the peak. The command module flew with lift, banking to control it, so it slowed down more gradually than a ballistic body would.
+ *
+ * ```ts
+ * ballisticPeakDeceleration(11_032, toRad(-6.48), 7200) / 9.80665; // ≈ 35.8 g
+ * ```
+ *
+ * :::
+ *
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Peak deceleration $ a_\text{max} $ in **m/s²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE <= 0`, `H <= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Entering at 7.8 km/s, 2° below horizontal
+ * const a = ballisticPeakDeceleration(7800, (-2 * Math.PI / 180) as Radians, 7200);
+ * // a ≈ 54 m/s², about 5.5 g
+ * ```
+ *
+ * @see {@link ballisticPeakDecelerationAltitude}
+ * @see {@link ballisticEntrySpeed}
+ */
+export declare const ballisticPeakDeceleration: (VE: number, gamma: number, H: number) => number;
+//# sourceMappingURL=ballistic-peak-deceleration.d.ts.map

package/dist/categories/entry/ballistic-peak-deceleration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,yBAAyB,GACpC,IAAI,MAAM,EACV,OAAO,MAAM,EACb,GAAG,MAAM,KACR,MAaF,CAAC"}

package/dist/categories/entry/ballistic-peak-deceleration.js

@@ -0,0 +1,76 @@
+import { assertFinite, assertFlightPathAngle, assertPositive } from './validate.js';
+/**
+ * Compute the **peak deceleration of a ballistic entry**, with the Allen–Eggers solution.
+ *
+ * $$
+ * a_\text{max} = \frac{V_E^2 \sin\lvert\gamma\rvert}{2\,e\,H}
+ * $$
+ *
+ * reached when the speed has fallen to $ V_E / \sqrt{e} \approx 0.61\,V_E $.
+ *
+ * Where:
+ * - $ V_E $ is the speed at entry (m/s)
+ * - $ \gamma $ is the flight-path angle (rad)
+ * - $ H $ is the atmosphere's scale height (m)
+ * - $ e $ is Euler's number
+ *
+ * **Units**
+ * - Inputs: `VE` in **m/s**, `gamma` in **radians**, `H` in **m**.
+ * - Output: $ a_\text{max} $ in **m/s²**. Divide by 9.80665 for g.
+ *
+ * ::: info Notes
+ *
+ * - The peak doesn't depend on the vehicle's mass, size or drag: a heavier one just reaches it lower down. Only the entry speed and angle matter.
+ * - It grows with $ \sin\lvert\gamma\rvert $: a steeper entry is a harder one.
+ * - Same assumptions as {@link ballisticEntrySpeed}: no lift, no gravity, a straight path. A lifting entry spreads the deceleration out and peaks much lower.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, coming home
+ *
+ * **35.8 g**
+ *
+ * _A ballistic entry at 11.03 km/s and −6.48°, with H = 7.2 km_
+ *
+ * The crew felt 6.56 g at the peak. The command module flew with lift, banking to control it, so it slowed down more gradually than a ballistic body would.
+ *
+ * ```ts
+ * ballisticPeakDeceleration(11_032, toRad(-6.48), 7200) / 9.80665; // ≈ 35.8 g
+ * ```
+ *
+ * :::
+ *
+ * @param VE - Entry speed $ V_E $ in **m/s** (finite, > 0).
+ * @param gamma - Flight-path angle $ \gamma $ in **radians** (finite, non-zero, within [-π/2, π/2]).
+ * @param H - Scale height $ H $ in **m** (finite, > 0).
+ * @returns Peak deceleration $ a_\text{max} $ in **m/s²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `VE <= 0`, `H <= 0`, or `gamma` is zero or past vertical.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Entering at 7.8 km/s, 2° below horizontal
+ * const a = ballisticPeakDeceleration(7800, (-2 * Math.PI / 180) as Radians, 7200);
+ * // a ≈ 54 m/s², about 5.5 g
+ * ```
+ *
+ * @see {@link ballisticPeakDecelerationAltitude}
+ * @see {@link ballisticEntrySpeed}
+ */
+export const ballisticPeakDeceleration = (VE, gamma, H) => {
+    assertFinite([
+        ['VE', VE],
+        ['gamma', gamma],
+        ['H', H]
+    ]);
+    assertPositive([
+        ['VE', VE],
+        ['H', H]
+    ]);
+    assertFlightPathAngle(gamma);
+    return (VE * VE * Math.sin(Math.abs(gamma))) / (2 * Math.E * H);
+};
+//# sourceMappingURL=ballistic-peak-deceleration.js.map

package/dist/categories/entry/ballistic-peak-deceleration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballistic-peak-deceleration.js","sourceRoot":"","sources":["../../../src/categories/entry/ballistic-peak-deceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,EAAU,EACV,KAAa,EACb,CAAS,EACD,EAAE;IACV,YAAY,CAAC;QACX,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,cAAc,CAAC;QACb,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACT,CAAC,CAAC;IACH,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAE7B,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAClE,CAAC,CAAC"}

package/dist/categories/entry/stagnation-heat-flux.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Compute the **convective heat flux at the stagnation point** of an entry vehicle, with the Sutton–Graves relation.
+ *
+ * $$
+ * \dot q = k\,\sqrt{\frac{\rho}{R_n}}\;V^3
+ * $$
+ *
+ * Where:
+ * - $ \rho $ is the free-stream density (kg/m³)
+ * - $ R_n $ is the nose radius: the radius of curvature at the stagnation point (m)
+ * - $ V $ is the speed (m/s)
+ * - $ k $ depends on the atmosphere's composition: about $ 1.7415 \times 10^{-4} $ kg$^{1/2}$/m for Earth's air and $ 1.9027 \times 10^{-4} $ for Mars
+ *
+ * **Units**
+ * - Inputs: `rho` in **kg/m³**, `V` in **m/s**, `Rn` in **m**, `k` in **kg^½/m**.
+ * - Output: $ \dot q $ in **W/m²**.
+ *
+ * ::: info Notes
+ *
+ * - The $ V^3 $ is why returning from the Moon is so much harder on a heat shield than returning from Earth orbit: 11 km/s against 7.8 km/s is almost three times the heating.
+ * - A blunter nose (larger $ R_n $) heats less, which is why capsules have broad, rounded heat shields rather than sharp points.
+ * - Convective heating only. At lunar return speeds the hot shock layer also radiates, which this doesn't include.
+ *
+ * :::
+ *
+ * @param rho - Free-stream density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param V - Speed $ V $ in **m/s** (finite, > 0).
+ * @param Rn - Nose radius $ R_n $ in **m** (finite, > 0).
+ * @param k - Sutton–Graves constant $ k $ (finite, > 0). Defaults to `1.7415e-4`, for Earth.
+ * @returns Stagnation-point heat flux $ \dot q $ in **W/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // 11 km/s at about 60 km (ρ ≈ 3 × 10⁻⁴ kg/m³), with a 4.7 m nose radius
+ * const q = stagnationHeatFlux(3e-4, 11_000, 4.69);
+ * // q ≈ 1.85 MW/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export declare const stagnationHeatFlux: (rho: number, V: number, Rn: number, k?: number) => number;
+//# sourceMappingURL=stagnation-heat-flux.d.ts.map

package/dist/categories/entry/stagnation-heat-flux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagnation-heat-flux.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/stagnation-heat-flux.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,kBAAkB,GAC7B,KAAK,MAAM,EACX,GAAG,MAAM,EACT,IAAI,MAAM,EACV,UAAa,KACZ,MAYF,CAAC"}

package/dist/categories/entry/stagnation-heat-flux.js

@@ -0,0 +1,57 @@
+import { assertFinite, assertPositive } from './validate.js';
+/**
+ * Compute the **convective heat flux at the stagnation point** of an entry vehicle, with the Sutton–Graves relation.
+ *
+ * $$
+ * \dot q = k\,\sqrt{\frac{\rho}{R_n}}\;V^3
+ * $$
+ *
+ * Where:
+ * - $ \rho $ is the free-stream density (kg/m³)
+ * - $ R_n $ is the nose radius: the radius of curvature at the stagnation point (m)
+ * - $ V $ is the speed (m/s)
+ * - $ k $ depends on the atmosphere's composition: about $ 1.7415 \times 10^{-4} $ kg$^{1/2}$/m for Earth's air and $ 1.9027 \times 10^{-4} $ for Mars
+ *
+ * **Units**
+ * - Inputs: `rho` in **kg/m³**, `V` in **m/s**, `Rn` in **m**, `k` in **kg^½/m**.
+ * - Output: $ \dot q $ in **W/m²**.
+ *
+ * ::: info Notes
+ *
+ * - The $ V^3 $ is why returning from the Moon is so much harder on a heat shield than returning from Earth orbit: 11 km/s against 7.8 km/s is almost three times the heating.
+ * - A blunter nose (larger $ R_n $) heats less, which is why capsules have broad, rounded heat shields rather than sharp points.
+ * - Convective heating only. At lunar return speeds the hot shock layer also radiates, which this doesn't include.
+ *
+ * :::
+ *
+ * @param rho - Free-stream density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param V - Speed $ V $ in **m/s** (finite, > 0).
+ * @param Rn - Nose radius $ R_n $ in **m** (finite, > 0).
+ * @param k - Sutton–Graves constant $ k $ (finite, > 0). Defaults to `1.7415e-4`, for Earth.
+ * @returns Stagnation-point heat flux $ \dot q $ in **W/m²**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // 11 km/s at about 60 km (ρ ≈ 3 × 10⁻⁴ kg/m³), with a 4.7 m nose radius
+ * const q = stagnationHeatFlux(3e-4, 11_000, 4.69);
+ * // q ≈ 1.85 MW/m²
+ * ```
+ *
+ * @see {@link ballisticEntrySpeed}
+ * @see https://en.wikipedia.org/wiki/Atmospheric_entry Atmospheric entry
+ */
+export const stagnationHeatFlux = (rho, V, Rn, k = 1.7415e-4) => {
+    const inputs = [
+        ['rho', rho],
+        ['V', V],
+        ['Rn', Rn],
+        ['k', k]
+    ];
+    assertFinite(inputs);
+    assertPositive(inputs);
+    return k * Math.sqrt(rho / Rn) * V ** 3;
+};
+//# sourceMappingURL=stagnation-heat-flux.js.map

package/dist/categories/entry/stagnation-heat-flux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagnation-heat-flux.js","sourceRoot":"","sources":["../../../src/categories/entry/stagnation-heat-flux.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,GAAW,EACX,CAAS,EACT,EAAU,EACV,CAAC,GAAG,SAAS,EACL,EAAE;IACV,MAAM,MAAM,GAAG;QACb,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,CAAC;IAEX,YAAY,CAAC,MAAM,CAAC,CAAC;IACrB,cAAc,CAAC,MAAM,CAAC,CAAC;IAEvB,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC,CAAC"}

package/dist/categories/entry/terminal-velocity.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Compute the **terminal speed** of a falling body: where drag balances its weight.
+ *
+ * $$
+ * v_t = \sqrt{\frac{2\,m\,g}{\rho\, C_D\, A}}
+ * $$
+ *
+ * Where:
+ * - $ m $ is the mass (kg)
+ * - $ g $ is the local gravitational acceleration (m/s²)
+ * - $ \rho $ is the air density (kg/m³)
+ * - $ C_D $ is the drag coefficient (dimensionless)
+ * - $ A $ is the reference area (m²)
+ *
+ * **Units**
+ * - Inputs: `m` in **kg**, `g` in **m/s²**, `rho` in **kg/m³**, `Cd` dimensionless, `A` in **m²**.
+ * - Output: $ v_t $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - For a parachute, $ C_D $ and $ A $ are the canopy's. For a cluster, $ A $ is the total canopy area, and real clusters lose a little drag to interference between the canopies.
+ * - The density rises as the body descends, so the terminal speed falls: evaluate it at the altitude you care about, e.g. sea level for splashdown.
+ * - At $ v_t $, `atmosphericDragAcceleration` equals $ g $.
+ *
+ * :::
+ *
+ * @param m - Mass $ m $ in **kg** (finite, > 0).
+ * @param g - Gravitational acceleration $ g $ in **m/s²** (finite, > 0).
+ * @param rho - Air density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param Cd - Drag coefficient $ C_D $ (finite, > 0).
+ * @param A - Reference area $ A $ in **m²** (finite, > 0).
+ * @returns Terminal speed $ v_t $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // A 4.9 t capsule under three 25.5 m canopies (Cd ≈ 0.8) at sea level
+ * const v = terminalVelocity(4932, 9.80665, 1.225, 0.8, 3 * Math.PI * 12.75 ** 2);
+ * // v ≈ 8.0 m/s
+ * ```
+ *
+ * @see {@link ballisticCoefficient}
+ * @see https://en.wikipedia.org/wiki/Terminal_velocity Terminal velocity
+ */
+export declare const terminalVelocity: (m: number, g: number, rho: number, Cd: number, A: number) => number;
+//# sourceMappingURL=terminal-velocity.d.ts.map

package/dist/categories/entry/terminal-velocity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-velocity.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/terminal-velocity.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,gBAAgB,GAC3B,GAAG,MAAM,EACT,GAAG,MAAM,EACT,KAAK,MAAM,EACX,IAAI,MAAM,EACV,GAAG,MAAM,KACR,MAaF,CAAC"}

package/dist/categories/entry/terminal-velocity.js

@@ -0,0 +1,60 @@
+import { assertFinite, assertPositive } from './validate.js';
+/**
+ * Compute the **terminal speed** of a falling body: where drag balances its weight.
+ *
+ * $$
+ * v_t = \sqrt{\frac{2\,m\,g}{\rho\, C_D\, A}}
+ * $$
+ *
+ * Where:
+ * - $ m $ is the mass (kg)
+ * - $ g $ is the local gravitational acceleration (m/s²)
+ * - $ \rho $ is the air density (kg/m³)
+ * - $ C_D $ is the drag coefficient (dimensionless)
+ * - $ A $ is the reference area (m²)
+ *
+ * **Units**
+ * - Inputs: `m` in **kg**, `g` in **m/s²**, `rho` in **kg/m³**, `Cd` dimensionless, `A` in **m²**.
+ * - Output: $ v_t $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - For a parachute, $ C_D $ and $ A $ are the canopy's. For a cluster, $ A $ is the total canopy area, and real clusters lose a little drag to interference between the canopies.
+ * - The density rises as the body descends, so the terminal speed falls: evaluate it at the altitude you care about, e.g. sea level for splashdown.
+ * - At $ v_t $, `atmosphericDragAcceleration` equals $ g $.
+ *
+ * :::
+ *
+ * @param m - Mass $ m $ in **kg** (finite, > 0).
+ * @param g - Gravitational acceleration $ g $ in **m/s²** (finite, > 0).
+ * @param rho - Air density $ \rho $ in **kg/m³** (finite, > 0).
+ * @param Cd - Drag coefficient $ C_D $ (finite, > 0).
+ * @param A - Reference area $ A $ in **m²** (finite, > 0).
+ * @returns Terminal speed $ v_t $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is `<= 0`.
+ * @group Entry
+ *
+ * @example
+ * ```ts
+ * // A 4.9 t capsule under three 25.5 m canopies (Cd ≈ 0.8) at sea level
+ * const v = terminalVelocity(4932, 9.80665, 1.225, 0.8, 3 * Math.PI * 12.75 ** 2);
+ * // v ≈ 8.0 m/s
+ * ```
+ *
+ * @see {@link ballisticCoefficient}
+ * @see https://en.wikipedia.org/wiki/Terminal_velocity Terminal velocity
+ */
+export const terminalVelocity = (m, g, rho, Cd, A) => {
+    const inputs = [
+        ['m', m],
+        ['g', g],
+        ['rho', rho],
+        ['Cd', Cd],
+        ['A', A]
+    ];
+    assertFinite(inputs);
+    assertPositive(inputs);
+    return Math.sqrt((2 * m * g) / (rho * Cd * A));
+};
+//# sourceMappingURL=terminal-velocity.js.map

package/dist/categories/entry/terminal-velocity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-velocity.js","sourceRoot":"","sources":["../../../src/categories/entry/terminal-velocity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,CAAS,EACT,CAAS,EACT,GAAW,EACX,EAAU,EACV,CAAS,EACD,EAAE;IACV,MAAM,MAAM,GAAG;QACb,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,CAAC;IAEX,YAAY,CAAC,MAAM,CAAC,CAAC;IACrB,cAAc,CAAC,MAAM,CAAC,CAAC;IAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC"}

package/dist/categories/entry/validate.d.ts

@@ -0,0 +1,7 @@
+/** Throw a TypeError for each non-finite input, named as in the caller's signature. */
+export declare const assertFinite: (inputs: readonly (readonly [string, number])[]) => void;
+/** Throw a RangeError for each input that isn't strictly positive. */
+export declare const assertPositive: (inputs: readonly (readonly [string, number])[]) => void;
+/** Throw a RangeError unless the flight-path angle is a descent or climb, not level or past vertical. */
+export declare const assertFlightPathAngle: (gamma: number) => void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/categories/entry/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/categories/entry/validate.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,eAAO,MAAM,YAAY,GACvB,QAAQ,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,SAM/C,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,cAAc,GACzB,QAAQ,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,SAK/C,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,SAKlD,CAAC"}

package/dist/categories/entry/validate.js

@@ -0,0 +1,20 @@
+/** Throw a TypeError for each non-finite input, named as in the caller's signature. */
+export const assertFinite = (inputs) => {
+    for (const [name, x] of inputs) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+};
+/** Throw a RangeError for each input that isn't strictly positive. */
+export const assertPositive = (inputs) => {
+    for (const [name, x] of inputs) {
+        if (x <= 0)
+            throw new RangeError(`${name} must be > 0. Received: ${x}`);
+    }
+};
+/** Throw a RangeError unless the flight-path angle is a descent or climb, not level or past vertical. */
+export const assertFlightPathAngle = (gamma) => {
+    if (gamma === 0 || Math.abs(gamma) > Math.PI / 2)
+        throw new RangeError(`gamma must be non-zero and within [-π/2, π/2]. Received: ${gamma}`);
+};
+//# sourceMappingURL=validate.js.map

package/dist/categories/entry/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../src/categories/entry/validate.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,MAA8C,EAC9C,EAAE;IACF,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;AACH,CAAC,CAAC;AAEF,sEAAsE;AACtE,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,MAA8C,EAC9C,EAAE;IACF,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,GAAG,IAAI,2BAA2B,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC,CAAC;AAEF,yGAAyG;AACzG,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,KAAa,EAAE,EAAE;IACrD,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;QAC9C,MAAM,IAAI,UAAU,CAClB,4DAA4D,KAAK,EAAE,CACpE,CAAC;AACN,CAAC,CAAC"}

package/dist/categories/orbits/inclination-from-launch-azimuth.d.ts

@@ -17,7 +17,7 @@ import type { Radians } from '@interstellar-tools/types';
  *
  * ::: info Notes
  *
- * - `lat` is the **geocentric** latitude. Published latitudes are usually geodetic, which on Earth differ by up to 0.19°, and the inclination by about as much. Convert first (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ * - `lat` is the **geocentric** latitude. Published latitudes are usually geodetic, which on Earth differ by up to 0.19°, and the inclination by about as much. Convert first with {@link geodeticToBodyFixed}, at the point's height.
  * - The relation holds at every point of the ground track, not only at launch: an orbit never reaches a latitude higher than its inclination.
  * - Launching due east ($ \beta = 90° $) gives the lowest inclination a site can reach without a plane change: its own latitude.
  * - Azimuths between 180° and 360° head west, into retrograde orbits ($ i > 90° $).
@@ -27,14 +27,16 @@ import type { Radians } from '@interstellar-tools/types';
  *
  * ::: practice Apollo 11, entering Earth orbit
  *
- * **32.52°**
+ * **32.521°**
  *
- * _At orbit insertion: 32.497° N geocentric, heading 88.848°_
+ * _At orbit insertion: 32.502° N geocentric (32.672° geodetic, 191.1 km up), heading 88.848°_
  *
  * The flown parking orbit was inclined 32.521°. Apollo 11 entered orbit near the northernmost point of its track, heading almost due east. With the published geodetic latitude, 32.672°, the result would be 32.69°.
  *
  * ```ts
- * inclinationFromLaunchAzimuth(toRad(32.497), toRad(88.848)); // ≈ 32.52°
+ * const [x, y, z] = geodeticToBodyFixed(toRad(32.672), toRad(-52.694), 191_100, 6_378_137, 0.00669437999014);
+ * const lat = Math.atan2(z, Math.hypot(x, y)); // 32.502°
+ * inclinationFromLaunchAzimuth(lat, toRad(88.848)); // ≈ 32.521°
  * ```
  *
  * :::

package/dist/categories/orbits/inclination-from-launch-azimuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inclination-from-launch-azimuth.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/inclination-from-launch-azimuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,4BAA4B,GACvC,KAAK,OAAO,EACZ,SAAS,OAAO,KACf,OAgBF,CAAC"}
+{"version":3,"file":"inclination-from-launch-azimuth.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/inclination-from-launch-azimuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,4BAA4B,GACvC,KAAK,OAAO,EACZ,SAAS,OAAO,KACf,OAgBF,CAAC"}

package/dist/categories/orbits/inclination-from-launch-azimuth.js

@@ -16,7 +16,7 @@
  *
  * ::: info Notes
  *
- * - `lat` is the **geocentric** latitude. Published latitudes are usually geodetic, which on Earth differ by up to 0.19°, and the inclination by about as much. Convert first (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ * - `lat` is the **geocentric** latitude. Published latitudes are usually geodetic, which on Earth differ by up to 0.19°, and the inclination by about as much. Convert first with {@link geodeticToBodyFixed}, at the point's height.
  * - The relation holds at every point of the ground track, not only at launch: an orbit never reaches a latitude higher than its inclination.
  * - Launching due east ($ \beta = 90° $) gives the lowest inclination a site can reach without a plane change: its own latitude.
  * - Azimuths between 180° and 360° head west, into retrograde orbits ($ i > 90° $).
@@ -26,14 +26,16 @@
  *
  * ::: practice Apollo 11, entering Earth orbit
  *
- * **32.52°**
+ * **32.521°**
  *
- * _At orbit insertion: 32.497° N geocentric, heading 88.848°_
+ * _At orbit insertion: 32.502° N geocentric (32.672° geodetic, 191.1 km up), heading 88.848°_
  *
  * The flown parking orbit was inclined 32.521°. Apollo 11 entered orbit near the northernmost point of its track, heading almost due east. With the published geodetic latitude, 32.672°, the result would be 32.69°.
  *
  * ```ts
- * inclinationFromLaunchAzimuth(toRad(32.497), toRad(88.848)); // ≈ 32.52°
+ * const [x, y, z] = geodeticToBodyFixed(toRad(32.672), toRad(-52.694), 191_100, 6_378_137, 0.00669437999014);
+ * const lat = Math.atan2(z, Math.hypot(x, y)); // 32.502°
+ * inclinationFromLaunchAzimuth(lat, toRad(88.848)); // ≈ 32.521°
  * ```
  *
  * :::

package/dist/categories/orbits/inclination-from-launch-azimuth.js.map

@@ -1 +1 @@
-{"version":3,"file":"inclination-from-launch-azimuth.js","sourceRoot":"","sources":["../../../src/categories/orbits/inclination-from-launch-azimuth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,GAAY,EACZ,OAAgB,EACP,EAAE;IACX,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,SAAS,EAAE,OAAO,CAAC;KACZ,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;IAEvE,8CAA8C;IAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE1E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAY,CAAC;AACpC,CAAC,CAAC"}
+{"version":3,"file":"inclination-from-launch-azimuth.js","sourceRoot":"","sources":["../../../src/categories/orbits/inclination-from-launch-azimuth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,GAAY,EACZ,OAAgB,EACP,EAAE;IACX,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,SAAS,EAAE,OAAO,CAAC;KACZ,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;IAEvE,8CAA8C;IAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE1E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAY,CAAC;AACpC,CAAC,CAAC"}

package/dist/categories/orbits/surface-rotation-speed.d.ts

@@ -20,7 +20,7 @@ import type { Radians } from '@interstellar-tools/types';
  * - A rocket launched eastward gets this speed for free; one launched westward has to cancel it first.
  * - Earth's sidereal rotation rate is about 7.2921150 × 10⁻⁵ rad/s.
  * - A body that rotates backwards (Venus, Uranus) has a negative `omega`, and the result is negative: westward.
- * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude; {@link geodeticToBodyFixed} gives both.
  *
  * :::
  *

package/dist/categories/orbits/surface-rotation-speed.js

@@ -19,7 +19,7 @@
  * - A rocket launched eastward gets this speed for free; one launched westward has to cancel it first.
  * - Earth's sidereal rotation rate is about 7.2921150 × 10⁻⁵ rad/s.
  * - A body that rotates backwards (Venus, Uranus) has a negative `omega`, and the result is negative: westward.
- * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude; {@link geodeticToBodyFixed} gives both.
  *
  * :::
  *