ootk 7.0.3 → 7.1.0

package/dist/main.d.cts

@@ -407,7 +407,9 @@ declare enum SensorType {
     /** Passive RF sensor (SIGINT, no transmission) */
     PASSIVE_RF = "PASSIVE_RF",
     /** Bistatic radio telescope */
-    BISTATIC_RADIO_TELESCOPE = "BISTATIC_RADIO_TELESCOPE"
+    BISTATIC_RADIO_TELESCOPE = "BISTATIC_RADIO_TELESCOPE",
+    /** Telemetry, tracking, and command antenna (cooperative tracking dish) */
+    TT_C_ANTENNA = "TT_C_ANTENNA"
 }
 
 /**
@@ -2423,7 +2425,15 @@ declare abstract class GroundObject extends BaseObject {
     ecef(): EcefVec3<Kilometers>;
     /**
      * Calculates the Earth-Centered Inertial (ECI) position vector of the ground object at a given date.
-     * @variation optimized version of this.toGeodetic().toITRF().toJ2000().position;
+     *
+     * Uses the WGS84 ellipsoid (the same {@link llaRad2ecef} position that `ecef()` and
+     * `Satellite.rae()` use), rotated into TEME by GMST. It deliberately does not use the
+     * spherical-Earth `lla2eci()`: at mid latitudes that puts the observer ~20 km away from
+     * its WGS84 position, which skewed `Satellite.dopplerFactor()` by up to ~0.2 km/s of range
+     * rate near closest approach.
+     *
+     * The result is in TEME (GMST rotation only), the frame `Satellite.eci()` returns. For J2000
+     * use {@link toJ2000}, which also applies precession and nutation.
      * @param date The date for which to calculate the ECI position vector. Defaults to the current date.
      * @returns The ECI position vector of the ground object.
      */
@@ -2449,7 +2459,11 @@ declare abstract class GroundObject extends BaseObject {
     toGeodetic(): Geodetic;
     /**
      * Converts the ground position to J2000 inertial coordinates.
-     * Ground objects have zero velocity in the inertial frame (ignoring Earth rotation).
+     *
+     * The site is placed on the WGS84 ellipsoid in ITRF and rotated into J2000 with the full
+     * precession, nutation and sidereal-time chain ({@link ITRF.toJ2000}), so it is in the same
+     * frame as `Satellite.toJ2000()`. The velocity is the Earth-rotation velocity (omega x r,
+     * ~0.46 km/s at the equator): a ground site is fixed in ITRF, not in inertial space.
      * @param date - The date for the conversion (defaults to now)
      * @returns J2000 state vector
      */
@@ -2756,6 +2770,13 @@ declare abstract class FormatTle {
      * Format a value in TLE exponential notation for BSTAR or mean motion ddot.
      * Format: "sNNNNN±N" (8 chars) where mantissa has implied leading decimal point.
      * Example: 0.00017507 → " 17507-3" (i.e., .17507 × 10^-3)
+     *
+     * The result is ALWAYS exactly 8 characters. The field has room for a 5-digit
+     * mantissa and a single-digit exponent, so values needing more are folded into
+     * what the format can express: magnitudes below 1e-10 become zero (the usual
+     * convention for a drag term too small to write), and the 1e9-and-up case is
+     * saturated. Anything longer would push every later column of TLE line 1 to the
+     * right, which silently corrupts ephemeris type, element number and checksum.
      * @param value - The value to format
      * @returns Formatted 8-character string
      */
@@ -3305,6 +3326,48 @@ interface OmmParsedDataFormat {
     };
 }
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * The subset of {@link Sgp4WasmBase} the `Sgp4` class needs to route
+ * propagation through the USSF Astro Standards wasm build. Structural, so
+ * this module never imports `external/` at runtime and any loaded
+ * `Sgp4Wasm`/`Sgp4XpWasm` instance satisfies it.
+ */
+interface Sgp4WasmBackendLike {
+    readonly isLoaded: boolean;
+    addSat(line1: string, line2: string): bigint;
+    initSats(satKeys: readonly bigint[]): void;
+    propagateOnePosVelFast(satKey: bigint, minutesSinceEpoch: number): {
+        err: number;
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        velocity: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+
 /**
  * @author Theodore Kruczek
  * @description Orbital Object ToolKit (ootk) is a collection of tools for working
@@ -3333,6 +3396,37 @@ declare enum Sgp4GravConstants {
     wgs84 = "wgs84"
 }
 declare class Sgp4 {
+    /**
+     * Routes all subsequent `createSatrec`/`propagate` calls in this JavaScript
+     * context through the USSF Astro Standards SGP4 wasm build instead of the
+     * pure-TypeScript implementation. Pass a loaded `Sgp4Wasm` or `Sgp4XpWasm`
+     * instance (see `src/external/`).
+     *
+     * satKeys are attached to satrecs lazily on first propagation, so the
+     * backend can be activated before or after satrecs are created. Satrecs
+     * without TLE lines (e.g. built from an OMM) and TLEs the wasm library
+     * rejects fall back to the TypeScript implementation permanently.
+     * @param wasm A loaded wasm SGP4 instance.
+     */
+    static useWasmBackend(wasm: Sgp4WasmBackendLike): void;
+    /**
+     * Restores the pure-TypeScript SGP4 implementation.
+     */
+    static clearWasmBackend(): void;
+    /**
+     * Whether propagation is currently routed through a wasm backend.
+     */
+    static get isWasmBackendActive(): boolean;
+    /**
+     * Diagnostic counters for the wasm backend: distinct TLEs attached to the
+     * wasm registry vs permanently fallen back to the TypeScript
+     * implementation. A growing fallback count means part of the catalog is
+     * still propagating in TypeScript.
+     */
+    static get wasmBackendStats(): {
+        attached: number;
+        fallback: number;
+    };
     private static angle_;
     private static asinh_;
     static createSatrec(tleLine1: string, tleLine2: string, whichconst?: Sgp4GravConstants, opsmode?: Sgp4OpsMode): SatelliteRecord;
@@ -4805,8 +4899,13 @@ declare class Satellite extends SpaceObject {
      */
     az(observer: GroundObject, date?: Date): Degrees | null;
     /**
-     * Calculates the RAE (Range, Azimuth, Elevation) values for a given sensor and date. If no date is provided, the
-     * current time is used.
+     * Calculates the RAE (Range, Azimuth, Elevation) values and their rates for a given sensor
+     * and date. If no date is provided, the current time is used.
+     *
+     * The rates are central differences of `rae()` over +/-0.5 s, stored in the units the
+     * {@link RAE} class expects: km/s for range rate and rad/s for the angle rates (read them
+     * in deg/s with `azRate` / `elRate`). The azimuth change is wrapped so a pass through
+     * north does not produce a 360 deg jump.
      * @variation expanded
      * @param observer - The observer's position on the ground.
      * @param date - The date at which to calculate the RAE values. Optional, defaults to the current date.
@@ -5167,11 +5266,12 @@ declare class Satellite extends SpaceObject {
     /**
      * Calculates the angle between this satellite, another satellite, and the Sun.
      *
-     * Returns the angle at this satellite between the vector to the other satellite
-     * and the vector to the Sun.
+     * Returns the angle at the OTHER satellite between its vector to the Sun and its vector
+     * to this satellite: the solar phase angle of `other` as seen from this satellite
+     * (0 = fully lit face toward this satellite, pi = backlit).
      *
      * @param other - The other satellite.
-     * @param sunPosition - The Sun's ECI position vector.
+     * @param sunPosition - The Sun's position in TEME (the frame of `eci()`), km.
      * @param date - The date for the calculation.
      * @returns The angle in radians.
      * @throws Error if positions are undefined.
@@ -5877,6 +5977,7 @@ declare enum SpaceObjectType {
     DWARF_PLANET = 36,
     MOON = 37,
     DYNAMIC_GROUND_OBJECT = 38,
+    ASTEROID = 39,
     MAX_SPACE_OBJECT_TYPE = 40
 }
 /**
@@ -6440,6 +6541,26 @@ declare class FieldOfView {
      * @returns True if within FOV
      */
     containsDirection(direction: Vector3D, range: Kilometers): boolean;
+    /**
+     * Samples a unit direction on or inside the FOV cone.
+     *
+     * The cone cross-section is parameterized like a standard 2D ellipse in
+     * angular (gnomonic) space: x = halfAngle * cos(t), y = minorHalfAngle * sin(t),
+     * where x is the off-boresight angle along the major axis (u) and y along the
+     * minor axis (v). Uniform steps in t produce well-distributed boundary points
+     * even for highly eccentric fans (e.g., an 80° x 1° fence radar), unlike
+     * uniform steps in the geometric position angle which clump at the fan tips.
+     *
+     * Points sampled with radialFraction < 1 always satisfy the elliptical cone
+     * containment check; radialFraction = 1 lies exactly on the boundary.
+     *
+     * @param t - Parametric ellipse angle in radians. t=0 points along the major
+     *            axis (+u), t=PI/2 along the minor axis (+v). Note this is NOT the
+     *            geometric position angle around the boresight.
+     * @param radialFraction - 0 = boresight, 1 = cone boundary (default: 1)
+     * @returns Unit direction vector in the FOV's reference frame (ENU for topocentric)
+     */
+    directionAt(t: Radians, radialFraction?: number): Vector3D;
     /**
      * Gets the effective minimum elevation at a given azimuth.
      * Considers all applicable elevation masks and returns the most restrictive.
@@ -7204,6 +7325,16 @@ declare class PhasedArrayRadar extends RadarSensor {
      * @returns Best face index, or -1 if no face is within 90° of target
      */
     getBestFace(az: Degrees, el: Degrees): number;
+    /**
+     * Great-circle angle between a look direction and a face's boresight, in degrees.
+     * (The face checks used sqrt(dAz^2 + dEl^2) with no azimuth wrap: 359 deg missed a 0 deg
+     * face, and azimuth differences were not shrunk by cos(elevation).)
+     * @param az - Target azimuth in degrees
+     * @param el - Target elevation in degrees
+     * @param face - Face index
+     * @returns Angle from boresight in degrees
+     */
+    private angleFromBoresight_;
     protected serializeSpecific(): Record<string, unknown>;
     /**
      * Creates a deep copy of this phased array radar.
@@ -7238,12 +7369,13 @@ declare class PhasedArrayRadar extends RadarSensor {
  */
 declare function ecef2eci<T extends number>(ecef: EcefVec3<T>, gmst: number): TemeVec3<T>;
 /**
- * Converts ECEF coordinates to ENU coordinates.
- * @param ecef - The ECEF coordinates.
- * @param lla - The LLA coordinates.
+ * Rotates an ECEF vector into the local East-North-Up axes at `lla` (a rotation only: pass
+ * a relative vector, e.g. target minus site, to get topocentric ENU).
+ * @param ecef - The ECEF vector.
+ * @param lla - The site latitude/longitude in RADIANS (geodetic).
  * @returns The ENU coordinates.
  */
-declare function ecef2enu<T extends number>(ecef: EcefVec3<T>, lla: LlaVec3): EnuVec3<T>;
+declare function ecef2enu<T extends number>(ecef: EcefVec3<T>, lla: LlaVec3<Radians, number>): EnuVec3<T>;
 /**
  * Converts TEME (True Equator Mean Equinox) to ECEF (Earth-Centered Earth-Fixed) coordinates.
  *
@@ -7290,15 +7422,21 @@ declare function llaRad2ecef<AltitudeUnits extends number>(lla: LlaVec3<Radians,
  */
 declare function lla2ecef<AltitudeUnits extends number>(lla: LlaVec3<Degrees, AltitudeUnits>): EcefVec3<AltitudeUnits>;
 /**
- * Converts geodetic coordinates (lat/lon/alt) to TEME (True Equator Mean Equinox) coordinates.
+ * Places lat/lon/alt on a SPHERICAL Earth (radius `Earth.radiusMean`) and rotates it into
+ * TEME by GMST.
  *
- * **Coordinate Frame Transformation: Geodetic → TEME**
+ * **Spherical-Earth helper, not a WGS84 site position.** The latitude is used as if it were
+ * geocentric, so for a geodetic (WGS84) latitude the result is up to ~21 km from the true
+ * position (about 7 km above the ellipsoid at the equator, 14 km below it at the poles, and
+ * offset north-south at mid latitudes). It is meant for drawing on a spherical globe of
+ * radius `Earth.radiusMean`.
  *
- * Converts WGS84 geodetic coordinates to inertial TEME coordinates via ECEF
- * and GMST rotation. Uses spherical Earth approximation (Earth.radiusMean).
+ * For a physical site position (look angles, range, Doppler, orbit determination) use
+ * `ecef2eci(llaRad2ecef(lla), gmst)` (WGS84, TEME), `GroundObject.eci()`, or
+ * `GroundObject.toJ2000()` for J2000.
  *
  * @variation cached - results are cached
- * @param lla - Geodetic coordinates (lat/lon in radians, alt in km)
+ * @param lla - Latitude/longitude in radians and altitude above the sphere in km
  * @param gmst - Greenwich Mean Sidereal Time in radians
  * @returns TEME coordinates (inertial)
  */
@@ -7339,10 +7477,10 @@ declare function rae2ecef<D extends number>(rae: RaeVec3<D, Degrees>, lla: LlaVe
 declare function rae2eci<D extends number>(rae: RaeVec3<D, Degrees>, lla: LlaVec3<Degrees, D>, gmst: number): TemeVec3<D>;
 /**
  * Converts a vector in RAE (Range, Azimuth, Elevation) coordinates to ENU (East, North, Up) coordinates.
- * @param rae - The vector in RAE coordinates.
+ * @param rae - The vector in RAE coordinates, with azimuth and elevation in RADIANS.
  * @returns The vector in ENU coordinates.
  */
-declare function rae2enu(rae: RaeVec3): EnuVec3<Kilometers>;
+declare function rae2enu(rae: RaeVec3<Kilometers, Radians>): EnuVec3<Kilometers>;
 /**
  * Converts South, East, and Zenith (SEZ) coordinates to Right Ascension, Elevation, and Range (RAE) coordinates.
  * @param sez The SEZ coordinates.
@@ -7873,9 +8011,19 @@ declare const spaceObjType2Str: (spaceObjType: SpaceObjectType) => string;
  * Calculates the Doppler factor for a given location, position, and velocity.
  * The Doppler factor is a measure of the change in frequency or wavelength of a wave
  * as observed by an observer moving relative to the source of the wave.
- * @param location - The location vector of the observer.
- * @param position - The position vector of the source.
- * @param velocity - The velocity vector of the source.
+ *
+ * Returns `1 - rangeRate / c`, so observed = transmitted * factor: above 1 while the
+ * source approaches, below 1 while it recedes.
+ *
+ * All three vectors must be in the same inertial frame (TEME, as from `Satellite.eci()`
+ * and `GroundObject.eci()`), despite the `EcefVec3` parameter types: the observer is
+ * treated as Earth-fixed and its rotational velocity (omega x r) is subtracted here.
+ * The observer position must be the WGS84 one that `rae()` uses; a spherical-Earth
+ * observer (`lla2eci()`) sits ~20 km off at mid latitudes and skews the range rate by
+ * up to ~0.2 km/s near closest approach.
+ * @param location - The observer position (inertial frame, km).
+ * @param position - The source position (inertial frame, km).
+ * @param velocity - The source velocity (inertial frame, km/s).
  * @returns The calculated Doppler factor.
  */
 declare const dopplerFactor: (location: EcefVec3<Kilometers>, position: EcefVec3<Kilometers>, velocity: EcefVec3<KilometersPerSecond>) => number;
@@ -8367,13 +8515,19 @@ declare class DynamicGroundObject extends GroundObject {
     getEcef(time: Date): EcefVec3<Kilometers> | null;
     /**
      * Gets the ECI (Earth-Centered Inertial) position at a specific time.
+     *
+     * The WGS84 position from {@link getEcef} rotated into TEME by GMST, the same model
+     * `GroundObject.eci()` uses (not the spherical-Earth `lla2eci()`).
      * @param time - The time to get position for
-     * @returns ECI position vector, or null if time is outside waypoint range
+     * @returns ECI (TEME) position vector, or null if time is outside waypoint range
      */
     getEci(time: Date): TemeVec3<Kilometers> | null;
     /**
      * Converts position at a specific time to J2000 inertial coordinates.
-     * Ground objects have zero velocity in the inertial frame (ignoring Earth rotation).
+     *
+     * The WGS84 position is rotated from ITRF into J2000 with precession, nutation and
+     * sidereal time, as in `GroundObject.toJ2000()`. The velocity is the Earth-rotation
+     * velocity (omega x r); the platform's own motion between waypoints is not included.
      * @param time - The time for the conversion
      * @returns J2000 state vector, or null if time is outside waypoint range
      */
@@ -9498,16 +9652,21 @@ declare abstract class CelestialBody extends BaseObject {
      * Gets rise, transit, and set times for this body as seen from a ground location.
      * @param observer - The ground observer location
      * @param date - The starting date for the search
-     * @param minElevation - Minimum elevation angle in degrees (default 0)
+     * @param minElevation - Elevation threshold in degrees (default 0). At 0 the times are the
+     * usual rise/set (upper limb on the horizon, with refraction); otherwise they are when the
+     * body's centre crosses that geometric elevation.
      * @returns Rise, transit, and set times (null if body doesn't rise/set)
      */
     getRiseSetTimes(observer: GroundObject, date?: Date, minElevation?: Degrees): RiseSetTimes;
     /**
      * Calculates the angular diameter of this body as seen from a given position.
-     * @param observerPos - The observer's position in km
+     * @param observerPos - The observer's position in km (J2000, at `date`)
+     * @param date - The time of `observerPos` (defaults to now). The body is placed at this
+     * time; without it a past or future observer position was paired with the body's
+     * position now.
      * @returns Angular diameter in radians
      */
-    getAngularDiameter(observerPos: Vector3D<Kilometers>): Radians;
+    getAngularDiameter(observerPos: Vector3D<Kilometers>, date?: Date): Radians;
     /**
      * Calculates the angular separation between this body and a target position.
      * @param targetPos - The target position in ECI coordinates (km)
@@ -9597,9 +9756,13 @@ declare class SunBody extends CelestialBody {
      */
     eci(date?: Date): Vector3D<Kilometers>;
     /**
-     * Gets the Sun's apparent position (corrected for light travel time).
+     * Gets the Sun's apparent position (corrected for light travel time and aberration).
+     *
+     * Same as {@link eci}: astronomy-engine's `GeoVector` already applies the light-time and
+     * aberration corrections. (This used to roll the time back by another ~499 s, putting the
+     * Sun a further ~20 arcsec along its path.)
      * @param date - The date/time for the position calculation
-     * @returns Position vector in kilometers
+     * @returns Position vector in kilometers (J2000)
      */
     eciApparent(date?: Date): Vector3D<Kilometers>;
     /**
@@ -9651,8 +9814,13 @@ declare class SunBody extends CelestialBody {
     static sunSatEarthAngle(satPos: Vector3D<Kilometers>, sunPos: Vector3D<Kilometers>): Degrees;
     /**
      * Determines if a satellite is in Earth's shadow.
+     *
+     * The test is a cylinder-plus-cone that tracks the umbra boundary closely (within ~0.01 deg
+     * of the `lightingRatio` umbra edge in LEO); a satellite in the penumbra counts as lit. Use
+     * {@link lightingRatio} when partial illumination matters.
      * @param epoch - The epoch for the calculation
-     * @param satPos - The satellite's ECI position in kilometers
+     * @param satPos - The satellite's position in J2000 (the frame of `eci()`), km; a TEME
+     * position from `Satellite.eci()` is ~0.3 deg off in 2026
      * @example
      * ```typescript
      * import { Sun, Satellite, EpochUTC, Vector3D, Kilometers, Seconds } from 'ootk';
@@ -9661,14 +9829,8 @@ declare class SunBody extends CelestialBody {
      * const now = new Date();
      * const epoch = new EpochUTC((now.getTime() / 1000) as Seconds);
      *
-     * const pv = satellite.eci(now);
-     * if (pv) {
-     *   const satPos = new Vector3D<Kilometers>(
-     *     pv.position.x as Kilometers,
-     *     pv.position.y as Kilometers,
-     *     pv.position.z as Kilometers
-     *   );
-     *
+     * const satPos = satellite.toJ2000(now).position; // J2000, like Sun.eci()
+     * {
      *   const inShadow = Sun.shadow(epoch, satPos);
      *   console.log(inShadow ? 'Satellite is in eclipse' : 'Satellite is sunlit');
      *
@@ -9701,10 +9863,11 @@ declare class SunBody extends CelestialBody {
     lightingRatio(satPos: Vector3D<Kilometers>, sunPos: Vector3D<Kilometers>): number;
     /**
      * Calculates the Sun's angular diameter as seen from a position.
-     * @param obsPos - Observer position in kilometers
+     * @param obsPos - Observer position in kilometers (J2000, at `date`)
+     * @param date - The time of `obsPos` (defaults to now)
      * @returns Angular diameter in radians
      */
-    diameter(obsPos: Vector3D<Kilometers>): Radians;
+    diameter(obsPos: Vector3D<Kilometers>, date?: Date): Radians;
     /**
      * Calculates comprehensive sun times for a given location and date.
      *
@@ -9741,9 +9904,13 @@ declare class SunBody extends CelestialBody {
     getTimes(dateVal: Date | number, lat: Degrees, lon: Degrees, alt?: Meters, isUtc?: boolean): SunTime;
     /**
      * Gets sunrise and sunset times using astronomy-engine.
+     *
+     * The times are when the Sun's centre crosses `minElevation` (geometric altitude). The
+     * default -0.833 deg is the standard sunrise/sunset definition (refraction plus the solar
+     * semidiameter); -6, -12 and -18 give civil, nautical and astronomical twilight.
      * @param observer - Ground observer location
      * @param date - The date for calculation
-     * @param minElevation - Minimum elevation in degrees (default -0.833 for standard sunrise)
+     * @param minElevation - Elevation of the Sun's centre in degrees (default -0.833 for standard sunrise)
      */
     getSunriseSunset(observer: GroundObject, date?: Date, minElevation?: Degrees): {
         sunrise: Date | null;
@@ -11396,6 +11563,555 @@ declare class RungeKutta4Propagator extends Propagator {
     restore(index: number): void;
 }
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * An Astro Standards satellite key returned by the TLE tree.
+ *
+ * Format: `JJJddddddYYSSSSSSSE` (Julian day, fraction of day, epoch year,
+ * 7-digit satellite number, element type). The value is 19 digits and exceeds
+ * `Number.MAX_SAFE_INTEGER`, so it must remain a `bigint` end-to-end.
+ */
+type SatKey = bigint;
+/**
+ * Logging levels accepted by `SetLogLevel_wasm`.
+ */
+declare enum Sgp4WasmLogLevel {
+    None = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}
+/**
+ * Sources for the Emscripten glue script and wasm binary.
+ *
+ * In Node both default to files that sit next to this module
+ * (`src/external/Sgp4Prop.js` / `.wasm`). In the browser there is no default;
+ * both must be provided (typically URLs served as static assets).
+ */
+interface Sgp4WasmLoadOptions {
+    /** Glue JS source: filesystem path, URL, or preloaded text (`{ text }`). */
+    glue?: string | URL | {
+        text: string;
+    };
+    /** Wasm binary source: filesystem path, URL, or raw bytes. */
+    wasm?: string | URL | Uint8Array | ArrayBuffer;
+    /** Forwarded to the Emscripten Module as its stdout hook. */
+    print?: (msg: string) => void;
+    /** Forwarded to the Emscripten Module as its stderr hook. */
+    printErr?: (msg: string) => void;
+}
+/**
+ * A single propagation record without geodetic coordinates
+ * (8 doubles per record in wasm memory).
+ *
+ * Position and velocity are in the TEME (true equator, mean equinox) frame,
+ * matching the output of the pure-TypeScript {@link Sgp4} class.
+ */
+interface Sgp4WasmPosVel {
+    /** SGP4 propagation error code for this record; 0 = success. */
+    err: number;
+    /**
+     * Echo of the propagation time: minutes since TLE epoch for the mse
+     * variants, or days since 1950 UTC for the ds50UTC variants.
+     */
+    time: number;
+    /** TEME position in kilometers. */
+    position: Vector3D<Kilometers>;
+    /** TEME velocity in kilometers per second. */
+    velocity: Vector3D<KilometersPerSecond>;
+}
+/**
+ * A full propagation record including geodetic coordinates
+ * (11 doubles per record in wasm memory).
+ */
+interface Sgp4WasmState extends Sgp4WasmPosVel {
+    /** Geodetic latitude/longitude/height. */
+    llh: {
+        lat: Degrees;
+        lon: Degrees;
+        height: Kilometers;
+    };
+}
+/**
+ * Result of the scratch-buffer fast path
+ * ({@link Sgp4WasmBase.propagateOnePosVelFast}). Plain numbers in the TEME
+ * frame (km, km/s) to avoid per-call allocations on hot paths.
+ */
+interface Sgp4WasmFastPosVel {
+    /** SGP4 propagation error code; 0 = success. */
+    err: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/**
+ * Error thrown by the Sgp4Wasm wrapper classes.
+ */
+declare class Sgp4WasmError extends Error {
+    readonly code?: number | undefined;
+    constructor(message: string, code?: number | undefined);
+}
+/**
+ * The subset of the evaluated Emscripten Module object used by the wrappers.
+ * Exposed via {@link Sgp4WasmBase.module} as a raw escape hatch.
+ */
+interface Sgp4PropEmscriptenModule {
+    _malloc(bytes: number): number;
+    _free(ptr: number): void;
+    /** Raw export used by the hot path to skip cwrap dispatch overhead. */
+    _Sgp4PropPosVel_wasm(keysPtr: number, numKeys: number, startMse: number, propsPerSat: number, stepMin: number, resultPtr: number): number;
+    cwrap(name: string, returnType: string | null, argTypes: string[]): (...args: unknown[]) => unknown;
+    ccall(name: string, returnType: string | null, argTypes: string[], args: unknown[]): unknown;
+    setValue(ptr: number, value: number | bigint, type: string): void;
+    getValue(ptr: number, type: string): number | bigint;
+    UTF8ToString(ptr: number, maxBytesToRead?: number): string;
+    HEAP8: Int8Array;
+    HEAPU8: Uint8Array;
+    HEAP32: Int32Array;
+    HEAPF64: Float64Array;
+    HEAP64: BigInt64Array;
+    wasmBinary?: ArrayBuffer | Uint8Array;
+    onRuntimeInitialized?: () => void;
+    onAbort?: (reason: unknown) => void;
+    print?: (msg: string) => void;
+    printErr?: (msg: string) => void;
+    calledRun?: boolean;
+}
+/**
+ * The subset of Emscripten's internal FS object captured during glue
+ * evaluation (it is not exported on the Module object). Needed for
+ * `TleLoadFileVFS_wasm`, which reads `inFile` and writes `outFile` in the
+ * virtual filesystem.
+ */
+interface Sgp4PropFS {
+    writeFile(path: string, data: string | Uint8Array): void;
+    readFile(path: string, opts: {
+        encoding: 'utf8';
+    }): string;
+    readFile(path: string, opts?: {
+        encoding: 'binary';
+    }): Uint8Array;
+    unlink(path: string): void;
+    analyzePath(path: string): {
+        exists: boolean;
+    };
+}
+/**
+ * Human-readable messages for the negative return codes shared by the
+ * dynamic-array management functions.
+ */
+declare const SGP4_WASM_DYN_ARR_ERRORS: Record<number, string>;
+/**
+ * Human-readable messages for the negative return codes of
+ * `AddSatToDynArr_wasm`.
+ */
+declare const SGP4_WASM_ADD_SAT_ERRORS: Record<number, string>;
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Base class wrapping the USSF Astro Standards "C Sgp4Prop WebAssembly"
+ * builds (v9.1.1.0). Concrete subclasses ({@link Sgp4Wasm} for classic SGP4,
+ * {@link Sgp4XpWasm} for SGP4-XP) only pick the artifact filenames.
+ *
+ * The Emscripten artifacts (`Sgp4Prop.js`/`.wasm` and the `.xp` pair) are
+ * license-restricted and distributed via space-track.org. They are NOT
+ * shipped with ootk; they must be placed in `src/external/` (Node default)
+ * or supplied explicitly through {@link Sgp4WasmLoadOptions}.
+ *
+ * The glue script is a classic non-modularized Emscripten build, which
+ * cannot be imported from an ES-module package (the internal `Module`
+ * object is unreachable). It is therefore fetched as text and evaluated in
+ * a controlled function scope with a pre-seeded `Module` (including
+ * `wasmBinary`, so Emscripten's file-location logic is never exercised).
+ * Note this requires `unsafe-eval` if a Content-Security-Policy is present.
+ *
+ * All propagation output is in the TEME frame, matching the pure-TypeScript
+ * {@link Sgp4} class.
+ */
+declare abstract class Sgp4WasmBase {
+    /** Glue script filename used for Node default resolution. */
+    protected abstract readonly defaultGlueFile_: string;
+    /** Wasm binary filename used for Node default resolution. */
+    protected abstract readonly defaultWasmFile_: string;
+    private module_;
+    private fs_;
+    private bindings_;
+    private loadPromise_;
+    private isDynArrInitialized_;
+    private scratchKeyPtr_;
+    private scratchResultPtr_;
+    /**
+     * Converts a UTC epoch to the Astro Standards ds50UTC time system
+     * (days since 1949 December 31, 00:00 UTC).
+     * @param epoch The epoch to convert.
+     * @returns Days since 1950 UTC.
+     */
+    static toDs50Utc(epoch: EpochUTC): number;
+    /**
+     * Whether the wasm runtime has been loaded and initialized.
+     */
+    get isLoaded(): boolean;
+    /**
+     * Raw Emscripten Module escape hatch (`_malloc`, `ccall`, heap views, ...).
+     * @throws {Sgp4WasmError} If the module is not loaded yet.
+     */
+    get module(): Sgp4PropEmscriptenModule;
+    /**
+     * Raw Emscripten virtual filesystem escape hatch.
+     * @throws {Sgp4WasmError} If the module is not loaded yet.
+     */
+    get fs(): Sgp4PropFS;
+    /**
+     * Loads and initializes the wasm runtime. Idempotent — repeat calls return
+     * the same in-flight or completed load.
+     * @param options Artifact sources and stdout/stderr hooks. In Node both
+     * artifacts default to files next to this module; in the browser both must
+     * be provided (typically URLs to statically served copies).
+     * @returns This instance, once the runtime is initialized.
+     */
+    load(options?: Sgp4WasmLoadOptions): Promise<this>;
+    /**
+     * Frees the dynamic array (if initialized) and drops all references to the
+     * wasm runtime so it can be garbage collected. Note Emscripten linear
+     * memory cannot be truly freed; a subsequent load() evaluates a fresh,
+     * isolated runtime.
+     */
+    dispose(): void;
+    /**
+     * Adds a single TLE to the TLE tree (`TleAddSatFrLines_wasm`).
+     * @param line1 Line 1 of the TLE.
+     * @param line2 Line 2 of the TLE.
+     * @returns The satKey of the added TLE.
+     */
+    addSat(line1: string, line2: string): SatKey;
+    /**
+     * Adds any number of TLEs from newline-separated text
+     * (`TleAddSatsFrLines_wasm`).
+     *
+     * The library adds TLEs individually: entries it fails to parse come back
+     * as `0n` in the returned array (positions match the input order), while
+     * the rest are added normally.
+     * @param tleText Newline-separated TLE lines.
+     * @returns One satKey per input TLE; `0n` marks a failed entry.
+     */
+    addSats(tleText: string): SatKey[];
+    /**
+     * Adds any number of TLEs through the Emscripten virtual filesystem
+     * (`TleLoadFileVFS_wasm`). The text is written to the VFS `inFile`, and
+     * the satKeys the library writes to `outFile` are read back.
+     * @param tleText Newline-separated TLE lines.
+     * @returns The satKeys of all added TLEs.
+     */
+    loadTlesVfs(tleText: string): SatKey[];
+    /**
+     * Removes TLEs from the TLE tree (`TleRemoveSats_wasm`).
+     * @param satKeys The satKeys to remove.
+     */
+    removeSats(satKeys: readonly SatKey[]): void;
+    /**
+     * Initializes SGP4 objects for previously added TLEs
+     * (`Sgp4InitSats_wasm`). Must be called after adding TLEs and before
+     * propagating them.
+     * @param satKeys The satKeys to initialize.
+     */
+    initSats(satKeys: readonly SatKey[]): void;
+    /**
+     * Removes initialized SGP4 objects (`Sgp4RemoveSats_wasm`).
+     * @param satKeys The satKeys to remove.
+     */
+    uninitSats(satKeys: readonly SatKey[]): void;
+    /**
+     * Propagates satKeys with geodetic output (`Sgp4Prop_wasm`).
+     * @param satKeys The satKeys to propagate (must be initialized).
+     * @param startTimeMse Start time in minutes since each TLE's epoch.
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagate(satKeys: readonly SatKey[], startTimeMse: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmState[][];
+    /**
+     * Propagates satKeys, position/velocity only (`Sgp4PropPosVel_wasm`).
+     * @param satKeys The satKeys to propagate (must be initialized).
+     * @param startTimeMse Start time in minutes since each TLE's epoch.
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagatePosVel(satKeys: readonly SatKey[], startTimeMse: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmPosVel[][];
+    /**
+     * Propagates satKeys from an absolute time with geodetic output
+     * (`Sgp4PropDs50Utc_wasm`).
+     * @param satKeys The satKeys to propagate (must be initialized).
+     * @param startTimeDs50Utc Start time in days since 1950 UTC (see {@link toDs50Utc}).
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagateDs50Utc(satKeys: readonly SatKey[], startTimeDs50Utc: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmState[][];
+    /**
+     * Propagates satKeys from an absolute time, position/velocity only
+     * (`Sgp4PropDs50UtcPosVel_wasm`).
+     * @param satKeys The satKeys to propagate (must be initialized).
+     * @param startTimeDs50Utc Start time in days since 1950 UTC (see {@link toDs50Utc}).
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagateDs50UtcPosVel(satKeys: readonly SatKey[], startTimeDs50Utc: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmPosVel[][];
+    /**
+     * Convenience single-satellite, single-step propagation.
+     * @param satKey The satKey to propagate (must be initialized).
+     * @param minutesSinceEpoch Minutes since the TLE epoch.
+     * @returns The propagated state.
+     */
+    propagateOne(satKey: SatKey, minutesSinceEpoch: number): Sgp4WasmState;
+    /**
+     * Convenience single-satellite propagation to an absolute UTC epoch.
+     * @param satKey The satKey to propagate (must be initialized).
+     * @param epoch The UTC epoch to propagate to.
+     * @returns The propagated state.
+     */
+    propagateEpoch(satKey: SatKey, epoch: EpochUTC): Sgp4WasmState;
+    /**
+     * Hot-path single-satellite propagation (`Sgp4PropPosVel_wasm`) that reuses
+     * persistent scratch buffers instead of allocating per call, and returns
+     * plain numbers instead of Vector3D instances. Intended for per-frame use
+     * (e.g. as a drop-in backend for `Sgp4.propagate`).
+     * @param satKey The satKey to propagate (must be initialized).
+     * @param minutesSinceEpoch Minutes since the TLE epoch.
+     * @returns Plain TEME position/velocity plus the per-record error code; a
+     * nonzero function-level failure is reported as `err` too.
+     */
+    propagateOnePosVelFast(satKey: SatKey, minutesSinceEpoch: number): Sgp4WasmFastPosVel;
+    /**
+     * Initializes the module-global dynamic array of SGP4 objects
+     * (`InitDynArr_wasm`).
+     * @param initialSize Initial capacity of the array.
+     */
+    initDynArr(initialSize: number): void;
+    /**
+     * Re-allocates the dynamic array to a new capacity
+     * (`ReallocateDynArr_wasm`).
+     * @param newSize New capacity of the array.
+     */
+    reallocDynArr(newSize: number): void;
+    /**
+     * Frees the dynamic array (`FreeDynArr_wasm`).
+     */
+    freeDynArr(): void;
+    /**
+     * Current size of the dynamic array (`GetDynArrSize_wasm`).
+     */
+    get dynArrSize(): number;
+    /**
+     * Adds a TLE to the dynamic array (`AddSatToDynArr_wasm`).
+     * @param line1 Line 1 of the TLE.
+     * @param line2 Line 2 of the TLE.
+     * @returns The dynamic array index of the added satellite.
+     */
+    addSatToDynArr(line1: string, line2: string): number;
+    /**
+     * Propagates dynamic array entries, position/velocity only
+     * (`Sgp4PropDynArrPosVel_wasm`).
+     * @param indexes Dynamic array indices to propagate.
+     * @param startTimeMse Start time in minutes since each TLE's epoch.
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagateDynArrPosVel(indexes: readonly number[], startTimeMse: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmPosVel[][];
+    /**
+     * Propagates dynamic array entries from an absolute time with geodetic
+     * output (`Sgp4PropDs50UtcDynArr_wasm`).
+     * @param indexes Dynamic array indices to propagate.
+     * @param startTimeDs50Utc Start time in days since 1950 UTC (see {@link toDs50Utc}).
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagateDs50UtcDynArr(indexes: readonly number[], startTimeDs50Utc: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmState[][];
+    /**
+     * Propagates dynamic array entries from an absolute time,
+     * position/velocity only (`Sgp4PropDs50UtcDynArrPosVel_wasm`).
+     * @param indexes Dynamic array indices to propagate.
+     * @param startTimeDs50Utc Start time in days since 1950 UTC (see {@link toDs50Utc}).
+     * @param propsPerSat Number of propagations per satellite.
+     * @param stepSizeMin Step size in minutes between propagations.
+     * @returns Records indexed as `[satIndex][stepIndex]`.
+     */
+    propagateDs50UtcDynArrPosVel(indexes: readonly number[], startTimeDs50Utc: number, propsPerSat: number, stepSizeMin: number): Sgp4WasmPosVel[][];
+    /**
+     * Sets the wasm library's logging level (`SetLogLevel_wasm`).
+     * @param level The new log level.
+     */
+    setLogLevel(level: Sgp4WasmLogLevel): void;
+    /**
+     * Counts the TLEs in newline-separated text by counting line-1 rows.
+     * @param tleText Newline-separated TLE lines.
+     * @returns Number of TLEs.
+     */
+    private static countTles_;
+    private static isHttpUrl_;
+    private fn_;
+    private loadInternal_;
+    private static buildBindings_;
+    private resolveGlueText_;
+    private resolveWasmBinary_;
+    private resolveDefaultSource_;
+    private readNodeFile_;
+    private missingArtifactError_;
+    private withMalloc_;
+    private withI64Array_;
+    private withI32Array_;
+    private readI64Array_;
+    /**
+     * Allocates a result buffer of `count` doubles, runs `fn`, and copies the
+     * buffer out. The HEAPF64 view is re-read from the module after the call
+     * because wasm memory growth invalidates cached views.
+     */
+    private withF64Result_;
+    private runKeysWithErrSat_;
+    private propagateKeys_;
+    private propagateIndexes_;
+    /**
+     * Parses a copied-out result buffer into per-satellite, per-step records.
+     * Records are 8 doubles wide (err, time, pos, vel) or 11 doubles wide
+     * (plus lat, lon, height) — the distribution docs' "7 per record"
+     * precondition is stale.
+     */
+    private parseRecords_;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Sgp4WasmPropagator adapts the USSF Astro Standards SGP4 WebAssembly
+ * wrappers ({@link Sgp4Wasm} / {@link Sgp4XpWasm}) to the same
+ * {@link Propagator} interface as {@link Sgp4Propagator}, so the official
+ * Astro Standards implementation can be swapped in for the pure-TypeScript
+ * SGP4.
+ *
+ * The wasm instance must already be loaded (`await wasm.load()`); the
+ * constructor registers and initializes the TLE synchronously. Call
+ * {@link dispose} to remove the satellite from the wasm instance's registry
+ * when done.
+ */
+declare class Sgp4WasmPropagator extends Propagator {
+    private readonly wasm_;
+    private readonly tle_;
+    private readonly satKey_;
+    private cacheState_;
+    private checkpoints_;
+    constructor(wasm_: Sgp4WasmBase, tle_: Tle);
+    /**
+     * The Astro Standards satKey backing this propagator.
+     */
+    get satKey(): SatKey;
+    /**
+     * Gets the state of the propagator in the J2000 coordinate system.
+     * @returns The J2000 state of the propagator.
+     */
+    get state(): J2000;
+    /**
+     * Calculates the ephemeris maneuver using the SGP4 propagator.
+     * @param start The start epoch in UTC.
+     * @param finish The finish epoch in UTC.
+     * @param maneuvers The array of thrust maneuvers.
+     * @param interval The time interval in seconds.
+     */
+    ephemerisManeuver(_start: EpochUTC, _finish: EpochUTC, _maneuvers: Thrust[], _interval?: number): VerletBlendInterpolator;
+    /**
+     * Performs a maneuver with the given thrust.
+     * @param maneuver - The thrust maneuver to perform.
+     * @param interval - The time interval for the maneuver (default: 60.0 seconds).
+     * @throws Error if maneuvers cannot be modeled with SGP4.
+     */
+    maneuver(_maneuver: Thrust, _interval?: number): J2000[];
+    /**
+     * Propagates the state to a specified epoch in J2000 coordinates.
+     * @param epoch - The epoch in UTC format.
+     * @returns The propagated state in J2000 coordinates.
+     */
+    propagate(epoch: EpochUTC): J2000;
+    /**
+     * Resets the state of the propagator to the TLE epoch state.
+     */
+    reset(): void;
+    /**
+     * Saves the current state of the propagator and returns the index of the checkpoint.
+     * @returns The index of the checkpoint.
+     */
+    checkpoint(): number;
+    /**
+     * Clears all the checkpoints in the propagator.
+     */
+    clearCheckpoints(): void;
+    /**
+     * Restores the state of the propagator to a previously saved checkpoint.
+     * @param index - The index of the checkpoint to restore.
+     */
+    restore(index: number): void;
+    /**
+     * Removes the satellite from the backing wasm instance's SGP4 and TLE
+     * registries.
+     */
+    dispose(): void;
+}
+
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -11925,6 +12641,18 @@ declare class ModifiedGoodingIOD {
     constructor(mu?: number);
     private createInitial_;
     private createErrorFunction_;
+    /**
+     * Solves for a J2000 state at the middle observation's epoch: a Gooding three-line-of-sight
+     * estimate refined by a downhill simplex over all observations with a two-body force model.
+     *
+     * `tolerance` ends the simplex once the spread of the summed line-of-sight error (radians)
+     * or of the vertices falls below it.
+     * @param observations - Optical observations, in time order (at least 3)
+     * @param r0 - Range guess for the first observation (km)
+     * @param rN - Range guess for the last observation (km)
+     * @param options - Solver options
+     * @returns The J2000 state at the middle observation's epoch
+     */
     solve(observations: ObservationOptical[], r0?: Kilometers, rN?: Kilometers, { nRev, direction, posSearch, velSearch, tolerance, maxIter, printIter, }?: SolveOptions): J2000;
     private defaultSolveOptions_;
 }
@@ -13290,6 +14018,94 @@ declare class PassiveRFSensor extends Sensor {
     clone(): PassiveRFSensor;
 }
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Parameters for constructing a TtcAntenna.
+ */
+interface TtcAntennaParams extends SensorParams {
+    /** Antenna dish diameter in meters */
+    antennaDiameter?: number;
+    /** Antenna gain in dB */
+    antennaGain?: number;
+    /** Whether the station supports two-way ranging */
+    hasRanging?: boolean;
+    /** Whether the station can uplink commands (vs receive-only) */
+    hasUplink?: boolean;
+}
+/**
+ * Telemetry, tracking, and command (TT&C) antenna.
+ *
+ * A steerable dish used to communicate with cooperative spacecraft. Unlike
+ * radars and telescopes, a TT&C antenna cannot detect non-cooperative
+ * objects; its "observations" come from tracking a transponding target
+ * (angles from autotrack, range/range-rate from two-way ranging and
+ * doppler). Range is limited by the link budget rather than a radar
+ * equation, so deep space networks can track targets millions of
+ * kilometers away.
+ *
+ * @example
+ * ```typescript
+ * const dss14 = new TtcAntenna({
+ *   id: 'dss-14',
+ *   name: 'Goldstone 70m',
+ *   sensorType: SensorType.TT_C_ANTENNA,
+ *   antennaDiameter: 70,
+ *   hasRanging: true,
+ *   hasUplink: true,
+ *   fieldOfView: {
+ *     minRange: 0 as Kilometers,
+ *     maxRange: 1e9 as Kilometers,
+ *     minAzimuth: 0 as Degrees,
+ *     maxAzimuth: 360 as Degrees,
+ *     minElevation: 6 as Degrees,
+ *     maxElevation: 90 as Degrees,
+ *   },
+ * });
+ * ```
+ */
+declare class TtcAntenna extends Sensor {
+    /** Antenna dish diameter in meters */
+    antennaDiameter?: number;
+    /** Antenna gain in dB */
+    antennaGain?: number;
+    /** Whether the station supports two-way ranging */
+    hasRanging: boolean;
+    /** Whether the station can uplink commands */
+    hasUplink: boolean;
+    constructor(params: TtcAntennaParams);
+    /**
+     * Creates an angle observation (Ra/Dec) of a cooperative target.
+     * Angles come from antenna autotrack while locked to the target's downlink.
+     * @param target - The space object to observe
+     * @param date - Time of observation (defaults to now)
+     * @returns ObservationOptical or null if target not in FOV
+     */
+    observe(target: SpaceObject, date?: Date): ObservationOptical | null;
+    protected serializeSpecific(): Record<string, unknown>;
+    /**
+     * Creates a deep copy of this TT&C antenna.
+     * The cloned sensor will not have a parent assigned.
+     * @returns A new TtcAntenna instance with the same properties
+     */
+    clone(): TtcAntenna;
+}
+
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -13458,19 +14274,26 @@ declare class HorizonsParser {
      * @returns Parsed observer data
      */
     static parseObserver(data: string): HorizonsObserverResult;
+    /** Metadata labels recognized in Horizons output headers. */
+    private static readonly metadataLabels_;
     /**
-     * Extracts a value from a key: value line.
+     * Extracts a metadata value from a `Label : value` line, tolerating the
+     * column-aligned padding Horizons inserts before the colon (e.g.
+     * "Output units    : KM-S"). Returns null if the line does not carry the
+     * given label.
      */
-    private static extractValue_;
+    private static extractLabeledValue_;
+    /** Returns the first recognized metadata label/value on the line, if any. */
+    private static matchMetadataLine_;
     /**
-     * Extracts the target body name, stripping parenthetical descriptors and IDs.
+     * Strips parenthetical descriptors and IDs from a target body name.
      *
      * Horizons format examples:
-     * - "1 Ceres                       {source: astDys}" → "1 Ceres"
-     * - "Artemis II (spacecraft) (-1024) {source: ...}"  → "Artemis II"
-     * - "Mars (499)"                                     → "Mars"
+     * - "1 Ceres"                       → "1 Ceres"
+     * - "Artemis II (spacecraft) (-1024)" → "Artemis II"
+     * - "Mars (499)"                    → "Mars"
      */
-    private static extractTargetName_;
+    private static stripNameSuffixes_;
     /**
      * Parses a vector data line from Horizons output.
      * Horizons vector output can span multiple lines.
@@ -15649,6 +16472,59 @@ declare class PlaneChangeBurn {
     static velocityAtTrueAnomaly(semimajorAxis: Kilometers, eccentricity: number, trueAnomaly: Radians, mu: number): number;
 }
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * Tsiolkovsky rocket-equation helpers for tracking a satellite's propellant
+ * budget across a sequence of impulsive burns.
+ *
+ * All masses are in kilograms, delta-V in meters per second, and specific
+ * impulse in seconds.
+ */
+declare class PropellantBudget {
+    /** Standard gravity used by the specific-impulse definition (m/s^2). */
+    static readonly g0 = 9.80665;
+    /**
+     * Mass remaining after an impulsive burn: `m * exp(-dv / (isp * g0))`.
+     * @param massKg Total mass before the burn. (kg)
+     * @param deltaVMs Delta-V of the burn. (m/s)
+     * @param ispS Specific impulse of the propulsion system. (s)
+     * @returns Total mass after the burn. (kg)
+     */
+    static massAfterBurn(massKg: number, deltaVMs: number, ispS: number): number;
+    /**
+     * Propellant consumed by an impulsive burn.
+     * @param massKg Total mass before the burn. (kg)
+     * @param deltaVMs Delta-V of the burn. (m/s)
+     * @param ispS Specific impulse of the propulsion system. (s)
+     * @returns Propellant mass consumed. (kg)
+     */
+    static propellantUsed(massKg: number, deltaVMs: number, ispS: number): number;
+    /**
+     * Delta-V available before the propellant is exhausted:
+     * `isp * g0 * ln(m / dry)`.
+     * @param massKg Current total mass. (kg)
+     * @param dryMassKg Dry mass (no propellant). (kg)
+     * @param ispS Specific impulse of the propulsion system. (s)
+     * @returns Remaining delta-V. (m/s)
+     */
+    static deltaVRemaining(massKg: number, dryMassKg: number, ispS: number): number;
+}
+
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -15666,6 +16542,23 @@ declare class PlaneChangeBurn {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
+type PlaneChangeAssignment = 'burn1' | 'burn2' | 'none';
+interface HohmannTransferWithPlaneChangeResult {
+    /** Circular speed of the initial orbit (km/s). */
+    vInit: number;
+    /** Circular speed of the final orbit (km/s). */
+    vFinal: number;
+    /** Delta-V magnitude of the first burn (km/s). */
+    deltaV1: number;
+    /** Delta-V magnitude of the second burn (km/s). */
+    deltaV2: number;
+    /** Total delta-V for both burns (km/s). */
+    deltaVTotal: number;
+    /** Coast time between the two burns (s). */
+    tTrans: Seconds;
+    /** Which burn carries the plane change. */
+    planeChangeBurn: PlaneChangeAssignment;
+}
 declare class TwoBurnOrbitTransfer {
     vInit: number;
     vFinal: number;
@@ -15680,6 +16573,23 @@ declare class TwoBurnOrbitTransfer {
      * @returns An instance of TwoBurnOrbitTransfer containing the calculated parameters.
      */
     static hohmannTransfer(rInit: number, rFinal: number): TwoBurnOrbitTransfer;
+    /**
+     * Calculates a Hohmann transfer between two circular orbits with an optional
+     * inclination change folded into one of the two burns as a single combined
+     * impulse.
+     *
+     * The plane change is cheapest where the orbital velocity is lowest. For a
+     * raising transfer that is the second burn (at rFinal); for a lowering
+     * transfer it is the first burn (at rInit). The plane change is auto-assigned
+     * to the cheaper burn and the assignment is reported in the result. A
+     * combined burn costs `sqrt(v1^2 + v2^2 - 2 * v1 * v2 * cos(deltaInc))`
+     * (law of cosines between the pre- and post-burn velocity vectors).
+     * @param rInit The initial orbit radius. (km)
+     * @param rFinal The final orbit radius. (km)
+     * @param deltaIncRad The inclination change. (rad)
+     * @returns Per-burn delta-V magnitudes, total, transfer time, and the plane-change assignment.
+     */
+    static hohmannTransferWithPlaneChange(rInit: number, rFinal: number, deltaIncRad: Radians): HohmannTransferWithPlaneChangeResult;
     get deltaV(): number;
     /**
      * Calculates the two maneuver thrusts required for a two-burn orbit transfer.
@@ -17212,10 +18122,15 @@ declare class LaunchTrajectoryGenerator {
      */
     private static greatCirclePoint_;
     /**
-     * Convert geodetic coordinates to ECI position.
-     * Uses spherical Earth approximation (consistent with lla2eci in transforms.ts).
+     * Convert geodetic coordinates to a J2000 position.
+     *
+     * The point is placed on the WGS84 ellipsoid in ITRF and rotated into J2000 with
+     * precession, nutation and sidereal time, so the trajectory starts on the same launch
+     * site a `GroundObject` at those coordinates reports. (A spherical Earth rotated by GMST
+     * alone, the earlier model, is a TEME position on the wrong surface: the pad sat ~17 km
+     * off on the sphere plus up to ~40 km of precession and nutation since J2000.)
      */
-    private static geodeticToEci_;
+    private static geodeticToJ2000_;
     /**
      * Compute the orbital velocity vector at the insertion point.
      * The velocity is tangent to the orbit (perpendicular to the radial direction),
@@ -17266,107 +18181,167 @@ declare class LaunchTrajectoryGenerator {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
+/** Options for {@link LaunchWindowFinder}. */
+interface LaunchWindowOptions {
+    /** Launch site geodetic latitude. */
+    siteLat: Degrees;
+    /** Launch site longitude (-180 to 180, east positive). */
+    siteLon: Degrees;
+    /** Inclination of the desired orbit. */
+    inclination: Degrees;
+    /** Whether the vehicle crosses the site heading north (ascending leg) or south (descending leg). */
+    direction: 'N' | 'S';
+    /**
+     * RAAN of the target orbital plane. Pass a function to account for the
+     * target's nodal drift over the search window (see {@link LaunchWindowFinder.meanRaanAt}).
+     */
+    targetRaan: Degrees | ((time: Date) => Degrees);
+    /** Start of the search window. */
+    startTime: Date;
+    /** Length of the search window in hours. Defaults to 24. */
+    searchHours?: number;
+    /** Coarse scan step in seconds. Defaults to 60. */
+    coarseStepSec?: number;
+    /** Refinement step in seconds around the best coarse sample. Defaults to 1. */
+    fineStepSec?: number;
+}
+/** A candidate launch time and the plane alignment it achieves. */
+interface LaunchWindowResult {
+    /** The launch time that best aligns the launch plane with the target plane. */
+    time: Date;
+    /** RAAN of the plane reachable by launching at {@link time}. (deg) */
+    achievableRaan: Degrees;
+    /** RAAN of the target plane at {@link time}. (deg) */
+    targetRaan: Degrees;
+    /** Signed alignment error achievable - target, normalized to [-180, 180). (deg) */
+    raanError: Degrees;
+}
 /**
- * Parameters describing an orbit's current state.
+ * Finds the launch time whose resulting orbital plane best matches a target
+ * plane's RAAN (a launch-window / RAAN-matching search).
+ *
+ * A launch site can only inject into planes that contain it, so for a fixed
+ * inclination the achievable RAAN is a function of launch time alone: the site
+ * rotates eastward under the candidate planes at Earth's rotation rate. This
+ * class computes that achievable RAAN in closed form (spherical geometry, no
+ * propagation) and scans a time window for the minimum |ΔRAAN| against the
+ * target plane.
+ *
+ * @example
+ * ```typescript
+ * const finder = new LaunchWindowFinder({
+ *   siteLat: 28.608 as Degrees,   // Kennedy Space Center
+ *   siteLon: -80.604 as Degrees,
+ *   inclination: 51.64 as Degrees,
+ *   direction: 'N',
+ *   targetRaan: (t) => LaunchWindowFinder.meanRaanAt(issSatrec, t),
+ *   startTime: new Date(),
+ * });
+ * const window = finder.findBestLaunchTime();
+ * ```
  */
-interface OrbitParameters {
-    meanAnomaly: number;
-    argOfPerigee: number;
-    raan: number;
-    altitude: number;
-    latitude: number;
-    longitude: number;
+declare class LaunchWindowFinder {
+    private readonly options_;
+    constructor(options: LaunchWindowOptions);
+    /**
+     * Whether the site can inject directly into the desired inclination: the
+     * orbit plane must reach the site's latitude, i.e. |sin(lat)| <= sin(inc).
+     */
+    isGeometryPossible(): boolean;
+    /**
+     * RAAN of the (only) plane with the configured inclination that contains the
+     * launch site at the given time on the configured leg. (deg, 0-360)
+     */
+    achievableRaan(time: Date): Degrees;
+    /**
+     * Scans the search window for the launch time minimizing |ΔRAAN| to the
+     * target plane, then refines around the best coarse sample. Returns null
+     * when the geometry is impossible (inclination below site latitude).
+     */
+    findBestLaunchTime(): LaunchWindowResult | null;
+    /**
+     * Mean RAAN of a satellite at a given time: the TLE epoch value advanced by
+     * the secular nodal drift (J2). Suitable as the `targetRaan` function so the
+     * target plane's regression over the search window is accounted for.
+     */
+    static meanRaanAt(satrec: SatelliteRecord, time: Date): Degrees;
+    private targetRaanAt_;
+    private raanErrorAt_;
+    private static julianDate_;
+    private static normalizeDeg_;
+    private static normalize180_;
 }
+
 /**
- * Options for OrbitFinder.
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
-interface OrbitFinderOptions {
-    /** Optional callback for debug messages */
-    debugCallback?: (message: string) => void;
+
+/** Cartesian TEME vector, km (position) or km/s (velocity). */
+interface StateVec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface GroundTrackState {
+    /** TEME position at the epoch (km). */
+    position: StateVec3;
+    /** TEME velocity at the epoch (km/s). */
+    velocity: StateVec3;
+}
+interface GroundTrackStateOptions {
+    /** Semi-major axis of the desired orbit (km). */
+    semimajorAxisKm: Kilometers;
+    /** Eccentricity of the desired orbit (0 for circular). */
+    eccentricity: number;
+    /** Inclination of the desired orbit (radians, 0..pi). */
+    inclinationRad: Radians;
+    /** Geodetic latitude of the launch site / target sub-point (radians). */
+    latRad: Radians;
+    /** Geodetic longitude of the launch site / target sub-point (radians, -pi..pi). */
+    lonRad: Radians;
+    /** GMST at the epoch (radians). */
+    gmstRad: GreenwichMeanSiderealTime;
+    /** Direction of ground-track motion at the sub-point: 'N' (ascending) or 'S' (descending). */
+    direction: 'N' | 'S';
 }
 /**
- * OrbitFinder is a utility class for manipulating satellite orbital parameters
- * to position a satellite over a specific latitude/longitude at a specific time.
+ * Builds a TEME state vector that places a satellite at **perigee, directly over a
+ * geodetic sub-point**, on an orbit of the requested shape and inclination, moving
+ * North (ascending) or South (descending) at that point.
  *
- * It works by taking an existing satellite's orbital parameters as a starting point
- * and searching for adjustments to orbital elements (mean anomaly, RAAN, argument of perigee)
- * until it finds a configuration that passes over the target location with the correct
- * directional motion (North or South).
+ * This is the closed-form replacement for the {@link OrbitFinder} ground-track
+ * search: instead of synthesizing candidate TLEs and iterating SGP4 until the
+ * sub-point converges (~2.8 km tolerance), it constructs the exact state
+ * analytically. Feed the result to `rv2tle` to fit SGP4 mean elements.
  *
- * @example
- * ```typescript
- * // Create an OrbitFinder for a circular orbit
- * const finder = new OrbitFinder(
- *   satellite,
- *   45.0 as Degrees,  // target latitude
- *   -122.0 as Degrees, // target longitude
- *   'N',              // moving north at target
- *   new Date()
- * );
- * const result = finder.rotateOrbitToLatLon();
- * if (result[0] !== 'Error') {
- *   const [tle1, tle2] = result;
- *   // Use the new TLE
- * }
+ * The position is built with the full WGS84 ellipsoid so `eci2lla(position, gmst)`
+ * returns the requested lat/lon exactly. The velocity is perpendicular to the
+ * radius vector (flight-path angle 0, i.e. perigee) with the horizontal azimuth
+ * fixed by the standard `cos(i) = sin(azimuth) * cos(geocentricLat)` relation, so
+ * the fitted orbit has the requested inclination. For a circular orbit (e = 0)
+ * this reduces to radius = a and speed = sqrt(mu / a).
  *
- * // For elliptical orbits, specify target altitude
- * const ellipticalFinder = new OrbitFinder(
- *   satellite,
- *   45.0 as Degrees,
- *   -122.0 as Degrees,
- *   'S',
- *   new Date(),
- *   400 as Kilometers  // target altitude for perigee
- * );
- * ```
+ * @returns the TEME position/velocity, or `null` when the target latitude is
+ * unreachable for the requested inclination (|cos(i)| > cos(geocentricLat)).
  */
-declare class OrbitFinder {
-    static readonly MAX_LAT_ERROR: Degrees;
-    static readonly MAX_LON_ERROR: Degrees;
-    static readonly MAX_ALT_ERROR: Kilometers;
-    static readonly MAX_ITERATIONS = 5000;
-    static readonly COARSE_STEP = 1;
-    static readonly FINE_STEP = 0.005;
-    private readonly sat_;
-    private readonly goalParams_;
-    private readonly now_;
-    private readonly goalDirection_;
-    private readonly debugCallback_?;
-    private currentParams_;
-    private lastLatitude_;
-    private currentDirection_;
-    constructor(sat: Satellite, goalLat: Degrees, goalLon: Degrees, goalDirection: 'N' | 'S', now: Date, goalAlt?: Kilometers, raanOffset?: number, options?: OrbitFinderOptions);
-    /**
-     * Rotates the orbit to pass over the target latitude/longitude at the specified time.
-     * @returns A tuple of [TleLine1, TleLine2] on success, or ['Error', message] on failure.
-     */
-    rotateOrbitToLatLon(): [TleLine1, TleLine2] | ['Error', string];
-    private debug_;
-    private calculateTimeVariables_;
-    private getCurrentOrbitParams_;
-    private determineDirection_;
-    private isCorrectDirection_;
-    private updateOrbit_;
-    private meanACalcLoop_;
-    private meanACalc_;
-    private linearSearchRaan_;
-    private normalizeAngleDifference_;
-    private calculateError_;
-    private updateOrbitWithoutDirectionCheck_;
-    private findPerigeePosition_;
-    /**
-     * Returns the 5-char satnum to embed in the synthesized TLEs.
-     *
-     * Why not {@link Satellite.sccNum}? For extended (7+ digit) IDs sccNum is
-     * the full 9-digit canonical value, which would push the TLE past 69 chars
-     * and break Sgp4.createSatrec. The input tle1 always has a valid 5-char
-     * satnum at columns 2-6, and SGP4 itself doesn't care what value lives
-     * there as long as line 1 and line 2 agree — so use that.
-     */
-    private tleSatNum_;
-    private generateTle1_;
-    private generateTle2_;
-}
+declare const groundTrackStateVector: (opts: GroundTrackStateOptions) => GroundTrackState | null;
+/** Semi-major axis (km) from an SGP4 mean motion in revolutions/day. */
+declare const semimajorAxisFromMeanMotion: (meanMotionRevPerDay: number) => Kilometers;
+/** Perigee speed (km/s) — exported for callers that need the vis-viva speed alongside the state. */
+declare const perigeeSpeed: (semimajorAxisKm: Kilometers, eccentricity: number) => KilometersPerSecond;
 
 /**
  * @author Theodore Kruczek
@@ -17552,4 +18527,68 @@ declare class RepeatGroundTrack {
     private static gcd_;
 }
 
-export { AccessCalculator, type AccessConstraints, AccessWindow, AngularDiameterMethod, AngularDistanceMethod, Antenna, type AntennaParams, AtmosphericDrag, type AzEl, BaseObject, type BaseObjectParams, BatchLeastSquaresOD, BatchLeastSquaresResult, Beacon, type BeaconParams, type BoresightFrame, BoxMuller, type CatalogObject, CatalogScreener, type CatalogScreeningOptions, CatalogSource, type CdmExportOptions, CdmExporter, type CdmHeader, type CdmManeuverableStatus, type CdmObjectData, type CdmObjectMetadata, type CdmObjectType, CdmParser, type CdmRelativeData, CelestialBody, type CelestialBodyParams, CelestialBodyType, CenterBody, CenterBodyMu, ChebyshevCoefficients, ChebyshevCompressor, ChebyshevInterpolator, ClassicalElements, type ClassicalElementsParams, CommDeviceType, CommLink, type CommPlatform, CommunicationDevice, type CommunicationDeviceInterface, type CommunicationDeviceParams, ConjunctionAssessment, type ConjunctionAssessmentOptions, ConjunctionEvent, type ConjunctionSpaceObjectInput, type ConsistencyRatioResult, ConstellationGenerator, ContactScheduler, ContactSelectionStrategy, CovarianceFrame, CovarianceRealism, type CovarianceRealismResult, CovarianceSample, type CoverageStatistics, CubicSpline, CubicSplineInterpolator, DEFAULT_INTERPOLATOR, DEFAULT_LAGRANGE_ORDER, DEG2RAD, DataHandler, type Days, type Dbm, type Dbw, type Decibels, type Degrees, type DegreesPerDay, type DegreesPerSecond, type DifferentiableFunction, DormandPrince54Propagator, DownhillSimplex, DynamicGroundObject, type DynamicGroundObjectParams, Earth, EarthGravity, type EcefVec3, type EigenvalueAnalysisResult, type ElevationMask, type EnuVec3, EphemerisBody, type EphemerisBodyParams, type EphemerisDataPoint, type EphemerisInterpolationType, EphemerisSatellite, type EphemerisSatelliteParams, Epoch, EpochGPS, EpochTAI, EpochTDB, EpochTT, EpochUTC, EpochWindow, EquinoctialElements, type EquinoctialElementsParams, EulerAngles, FieldInterpolator, FieldOfView, type FieldOfViewParams, type FindNearestOptions, Force, ForceModel, FormatTle, type FovBoundaryPoint, FovFrame, FovShape, type GcrfVec3, Geodetic, GibbsIOD, GoldenSection, GoodingIOD, Gravity, type GreenwichMeanSiderealTime, type GroundInterpolationMethod, GroundObject, type GroundObjectParams, type GroundPositionParams, GroundStation, type GroundStationParams, type GroundTrackPoint, HerrickGibbsIOD, type Hertz, Hill, type HistoricalState, History, type HistoryConfig, type HistoryEntry, type HorizonsEphemerisData, type HorizonsObserverResult, HorizonsParser, type HorizonsVectorResult, type Hours, ITRF, Interpolator, InterpolatorType, type ItrfVec3, J2000, type J2000Vec3, type JacobianFunction, Jupiter, KM_PER_AU, KeplerPropagator, type Kilometers, type KilometersPerSecond, LagrangeInterpolator, LambertIOD, LandObject, LaserRangingSensor, type LaserRangingSensorParams, type LaunchDetails, type LaunchTrajectoryConfig, LaunchTrajectoryGenerator, LevenbergMarquardtOD, LevenbergMarquardtResult, type LibrationData, type Line1Data, type Line2Data, type LinkBudget, type LlaVec3, type Lookangle, MILLISECONDS_PER_DAY, MILLISECONDS_PER_SECOND, MILLISECONDS_TO_DAYS, MINUTES_PER_DAY, MS_PER_DAY, type MahalanobisResult, Marker, Mars, Matrix, MechanicalRadar, type MechanicalRadarParams, Mercury, type Meters, type MetersPerSecond, type Milliseconds, type Minutes, ModifiedGoodingIOD, ModulationType, Moon, MoonBody, type MoonPhaseInfo, type MoonTimes, Neptune, type NumericalPropagatorOptions, type NutationAngles, Observation, ObservationOptical, ObservationRadar, type OdmExportOptions, OdmExporter, type OemCovarianceMatrix, type OemDataBlock, type OemExportOptions, type OemFromStateVectorsOptions, type OemHeader, type OemMetadata, OemParser, type OmmCovarianceMatrix, type OmmDataFormat, type OmmExportOptions, type OmmHeader, type OmmMeanElements, type OmmMetadata, type OmmParsedDataFormat, OmmParser, type OmmSpacecraftParameters, type OmmTleParameters, type OmmUserDefined, OotkError, type OperationsDetails, type OpmExportOptions, OpticalSensor, type OpticalSensorParams, type OptionsParams, OrbitDeterminationError, OrbitFinder, type OrbitFinderOptions, type OrbitParameters, OrbitRegime, type OrbitTrackPoint, type OrbitalShell, PI, ParseError, type ParsedCdm, type ParsedOem, type ParsedOmm, PassType, PassiveRFSensor, type PassiveRFSensorParams, PayloadStatus, PhasedArrayRadar, type PhasedArrayRadarParams, PlaneChangeBurn, PlanetBody, Pluto, PolynomialRegression, type PosVel, type PositionVelocity, type PrecessionAngles, ProbabilityOfCollision, PropagationError, Propagator, PropagatorType, Quaternion, RAD2DEG, RADIUS_OF_EARTH, RAE, RCS_VMAG_ESTIMATE_MAX, RCS_VMAG_ESTIMATE_MIN, RIC, type RaDec, RadarSensor, type RadarSensorParams, RadecGeocentric, RadecTopocentric, type Radians, type RadiansPerSecond, type RaeVec3, Random, RandomGaussianSource, type RcsShape, Receiver, type ReceiverParams, type ReferenceFrame, RelativeState, type RelayLinkBudget, RepeatGroundTrack, type RepeatGroundTrackOptions, type RepeatOrbitResult, type RfVec3, type RicSigmas, type RiseSetTimes, RkCheckpoint, RkResult, RungeKutta4Propagator, RungeKutta89Propagator, RungeKuttaAdaptive, type RuvVec3, type Rv2TleOptions, type Rv2TleResult, type RvVector, SLR_WAVELENGTHS, SPEED_OF_LIGHT_KM_S, type SatNumKind, Satellite, type SatelliteCoverageStats, type SatelliteParams, type SatelliteRecord, Saturn, type ScaleFactorResult, type ScheduleOptions, ScheduledContact, type ScheduledContactParams, ScreeningFilter, type ScreeningResult, type Seconds, type SecondsPerMeterPerSecond, SegmentedLagrangeInterpolator, Sensor, type SensorInterface, type SensorParams, type SensorPlatform, SensorType, type SerializedAntenna, type SerializedCommDevice, type SerializedObject, type SerializedSensor, type SezVec3, Sgp4, Sgp4Error, Sgp4ErrorCode, Sgp4OpsMode, Sgp4Propagator, type Sgp4Result, SimpleLinearRegression, SolarRadiationPressure, SolarSystem, type SpaceCraftDetails, SpaceObject, type SpaceObjectParams, SpaceObjectType, Star, type StarObjectParams, StateCovariance, StateInterpolator, StateVector, type StateVectorSgp4, type StationCoverageStats, type StringifiedNumber, Sun, SunBody, SunStatus, type SunTime, TAU, TEME, type TemeVec3, ThirdBodyGravity, Thrust, TimeStamped, type TimeWindow, Tle, type TleData, type TleDataFull, type TleLine1, type TleLine2, type TleParams, Transmitter, type TransmitterParams, Transponder, type TransponderParams, TwoBurnOrbitTransfer, Uranus, ValidationError, type Vec3, type Vec3Flat, Vector, Vector3D, Venus, VerletBlendInterpolator, VisualizationHelpers, type Watts, Waypoint, type WaypointData, ZoomValue, acoth, acsch, angularDiameter, angularDistance, angularVelocityOfEarth, array2d, asec2rad, asech, azel2uv, bodyTypeLookup, boresightFrameFromAzElRoll, cKmPerMs, cKmPerSec, cMPerSec, calcGmst, calcIncFromAz, calcInertAz, calculateFspl, calculatePropagationDelay, cappedScreeningCovarianceFromTle, clamp, concat, copySign, covariance, createCovarianceFromTle, createSampleCovarianceFromTle, createVec, csch, dbmToDbw, dbwToDbm, dbwToWatts, deg2rad, derivative, dopplerFactor, earthGravityParam, ecef2eci, ecef2enu, ecef2rae, ecefRad2rae, eci2ecef, eci2lla, eci2rae, enu2rf, estimateRcs, estimateVmagFromRcs, evalPoly, factorial, gamma, getDayOfYear, getDegLat, getDegLon, getRadLat, getRadLon, halfPi, isLeapYear, jacobian, jday, linearDistance, linearInterpolate, lla2ecef, lla2eci, lla2sez, llaRad2ecef, log10, mag2db, masec2rad, matchHalfPlane, mean, msec2sec, newtonM, newtonNu, normalizeAngle, observationDerivative, observationNoiseFromSigmas, parseCenterBody, rad2deg, radecToPosition, radecToVelocity, rae2ecef, rae2eci, rae2enu, rae2raeOffBoresight, rae2ruv, rae2sez, relativeVelocity, rv2tle, scaleAndClampRicSigmas, sec2day, sec2deg, sec2min, sech, secondsPerDay, secondsPerSiderealDay, secondsPerWeek, sez2rae, sign, spaceObjType2Str, std, temp4, toPrecision, ttasec2rad, uv2azel, wattsToDbw, wrapAngle, x2o3 };
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Classic SGP4 propagation via the official USSF Astro Standards
+ * "C Sgp4Prop WebAssembly" build (`Sgp4Prop.js` / `Sgp4Prop.wasm`).
+ *
+ * @example
+ * ```ts
+ * const sgp4 = await new Sgp4Wasm().load();
+ * const satKey = sgp4.addSat(line1, line2);
+ * sgp4.initSats([satKey]);
+ * const state = sgp4.propagateOne(satKey, 60); // 60 min past epoch
+ * ```
+ */
+declare class Sgp4Wasm extends Sgp4WasmBase {
+    protected readonly defaultGlueFile_ = "Sgp4Prop.js";
+    protected readonly defaultWasmFile_ = "Sgp4Prop.wasm";
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * SGP4-XP propagation via the official USSF Astro Standards
+ * "C Sgp4Prop WebAssembly" build (`Sgp4Prop.xp.js` / `Sgp4Prop.xp.wasm`).
+ *
+ * SGP4-XP is the extended propagator that additionally supports
+ * ephemeris-type-4 TLEs; for classic type-0 TLEs it produces results
+ * matching {@link Sgp4Wasm}. The API surface is identical.
+ */
+declare class Sgp4XpWasm extends Sgp4WasmBase {
+    protected readonly defaultGlueFile_ = "Sgp4Prop.xp.js";
+    protected readonly defaultWasmFile_ = "Sgp4Prop.xp.wasm";
+}
+
+export { AccessCalculator, type AccessConstraints, AccessWindow, AngularDiameterMethod, AngularDistanceMethod, Antenna, type AntennaParams, AtmosphericDrag, type AzEl, BaseObject, type BaseObjectParams, BatchLeastSquaresOD, BatchLeastSquaresResult, Beacon, type BeaconParams, type BoresightFrame, BoxMuller, type CatalogObject, CatalogScreener, type CatalogScreeningOptions, CatalogSource, type CdmExportOptions, CdmExporter, type CdmHeader, type CdmManeuverableStatus, type CdmObjectData, type CdmObjectMetadata, type CdmObjectType, CdmParser, type CdmRelativeData, CelestialBody, type CelestialBodyParams, CelestialBodyType, CenterBody, CenterBodyMu, ChebyshevCoefficients, ChebyshevCompressor, ChebyshevInterpolator, ClassicalElements, type ClassicalElementsParams, CommDeviceType, CommLink, type CommPlatform, CommunicationDevice, type CommunicationDeviceInterface, type CommunicationDeviceParams, ConjunctionAssessment, type ConjunctionAssessmentOptions, ConjunctionEvent, type ConjunctionSpaceObjectInput, type ConsistencyRatioResult, ConstellationGenerator, ContactScheduler, ContactSelectionStrategy, CovarianceFrame, CovarianceRealism, type CovarianceRealismResult, CovarianceSample, type CoverageStatistics, CubicSpline, CubicSplineInterpolator, DEFAULT_INTERPOLATOR, DEFAULT_LAGRANGE_ORDER, DEG2RAD, DataHandler, type Days, type Dbm, type Dbw, type Decibels, type Degrees, type DegreesPerDay, type DegreesPerSecond, type DifferentiableFunction, DormandPrince54Propagator, DownhillSimplex, DynamicGroundObject, type DynamicGroundObjectParams, Earth, EarthGravity, type EcefVec3, type EigenvalueAnalysisResult, type ElevationMask, type EnuVec3, EphemerisBody, type EphemerisBodyParams, type EphemerisDataPoint, type EphemerisInterpolationType, EphemerisSatellite, type EphemerisSatelliteParams, Epoch, EpochGPS, EpochTAI, EpochTDB, EpochTT, EpochUTC, EpochWindow, EquinoctialElements, type EquinoctialElementsParams, EulerAngles, FieldInterpolator, FieldOfView, type FieldOfViewParams, type FindNearestOptions, Force, ForceModel, FormatTle, type FovBoundaryPoint, FovFrame, FovShape, type GcrfVec3, Geodetic, GibbsIOD, GoldenSection, GoodingIOD, Gravity, type GreenwichMeanSiderealTime, type GroundInterpolationMethod, GroundObject, type GroundObjectParams, type GroundPositionParams, GroundStation, type GroundStationParams, type GroundTrackPoint, type GroundTrackState, type GroundTrackStateOptions, HerrickGibbsIOD, type Hertz, Hill, type HistoricalState, History, type HistoryConfig, type HistoryEntry, type HohmannTransferWithPlaneChangeResult, type HorizonsEphemerisData, type HorizonsObserverResult, HorizonsParser, type HorizonsVectorResult, type Hours, ITRF, Interpolator, InterpolatorType, type ItrfVec3, J2000, type J2000Vec3, type JacobianFunction, Jupiter, KM_PER_AU, KeplerPropagator, type Kilometers, type KilometersPerSecond, LagrangeInterpolator, LambertIOD, LandObject, LaserRangingSensor, type LaserRangingSensorParams, type LaunchDetails, type LaunchTrajectoryConfig, LaunchTrajectoryGenerator, LaunchWindowFinder, type LaunchWindowOptions, type LaunchWindowResult, LevenbergMarquardtOD, LevenbergMarquardtResult, type LibrationData, type Line1Data, type Line2Data, type LinkBudget, type LlaVec3, type Lookangle, MILLISECONDS_PER_DAY, MILLISECONDS_PER_SECOND, MILLISECONDS_TO_DAYS, MINUTES_PER_DAY, MS_PER_DAY, type MahalanobisResult, Marker, Mars, Matrix, MechanicalRadar, type MechanicalRadarParams, Mercury, type Meters, type MetersPerSecond, type Milliseconds, type Minutes, ModifiedGoodingIOD, ModulationType, Moon, MoonBody, type MoonPhaseInfo, type MoonTimes, Neptune, type NumericalPropagatorOptions, type NutationAngles, Observation, ObservationOptical, ObservationRadar, type OdmExportOptions, OdmExporter, type OemCovarianceMatrix, type OemDataBlock, type OemExportOptions, type OemFromStateVectorsOptions, type OemHeader, type OemMetadata, OemParser, type OmmCovarianceMatrix, type OmmDataFormat, type OmmExportOptions, type OmmHeader, type OmmMeanElements, type OmmMetadata, type OmmParsedDataFormat, OmmParser, type OmmSpacecraftParameters, type OmmTleParameters, type OmmUserDefined, OotkError, type OperationsDetails, type OpmExportOptions, OpticalSensor, type OpticalSensorParams, type OptionsParams, OrbitDeterminationError, OrbitRegime, type OrbitTrackPoint, type OrbitalShell, PI, ParseError, type ParsedCdm, type ParsedOem, type ParsedOmm, PassType, PassiveRFSensor, type PassiveRFSensorParams, PayloadStatus, PhasedArrayRadar, type PhasedArrayRadarParams, type PlaneChangeAssignment, PlaneChangeBurn, PlanetBody, Pluto, PolynomialRegression, type PosVel, type PositionVelocity, type PrecessionAngles, ProbabilityOfCollision, PropagationError, Propagator, PropagatorType, PropellantBudget, Quaternion, RAD2DEG, RADIUS_OF_EARTH, RAE, RCS_VMAG_ESTIMATE_MAX, RCS_VMAG_ESTIMATE_MIN, RIC, type RaDec, RadarSensor, type RadarSensorParams, RadecGeocentric, RadecTopocentric, type Radians, type RadiansPerSecond, type RaeVec3, Random, RandomGaussianSource, type RcsShape, Receiver, type ReceiverParams, type ReferenceFrame, RelativeState, type RelayLinkBudget, RepeatGroundTrack, type RepeatGroundTrackOptions, type RepeatOrbitResult, type RfVec3, type RicSigmas, type RiseSetTimes, RkCheckpoint, RkResult, RungeKutta4Propagator, RungeKutta89Propagator, RungeKuttaAdaptive, type RuvVec3, type Rv2TleOptions, type Rv2TleResult, type RvVector, SGP4_WASM_ADD_SAT_ERRORS, SGP4_WASM_DYN_ARR_ERRORS, SLR_WAVELENGTHS, SPEED_OF_LIGHT_KM_S, type SatKey, type SatNumKind, Satellite, type SatelliteCoverageStats, type SatelliteParams, type SatelliteRecord, Saturn, type ScaleFactorResult, type ScheduleOptions, ScheduledContact, type ScheduledContactParams, ScreeningFilter, type ScreeningResult, type Seconds, type SecondsPerMeterPerSecond, SegmentedLagrangeInterpolator, Sensor, type SensorInterface, type SensorParams, type SensorPlatform, SensorType, type SerializedAntenna, type SerializedCommDevice, type SerializedObject, type SerializedSensor, type SezVec3, Sgp4, Sgp4Error, Sgp4ErrorCode, Sgp4OpsMode, type Sgp4PropEmscriptenModule, type Sgp4PropFS, Sgp4Propagator, type Sgp4Result, Sgp4Wasm, Sgp4WasmBase, Sgp4WasmError, type Sgp4WasmFastPosVel, type Sgp4WasmLoadOptions, Sgp4WasmLogLevel, type Sgp4WasmPosVel, Sgp4WasmPropagator, type Sgp4WasmState, Sgp4XpWasm, SimpleLinearRegression, SolarRadiationPressure, SolarSystem, type SpaceCraftDetails, SpaceObject, type SpaceObjectParams, SpaceObjectType, Star, type StarObjectParams, StateCovariance, StateInterpolator, type StateVec3, StateVector, type StateVectorSgp4, type StationCoverageStats, type StringifiedNumber, Sun, SunBody, SunStatus, type SunTime, TAU, TEME, type TemeVec3, ThirdBodyGravity, Thrust, TimeStamped, type TimeWindow, Tle, type TleData, type TleDataFull, type TleLine1, type TleLine2, type TleParams, Transmitter, type TransmitterParams, Transponder, type TransponderParams, TtcAntenna, type TtcAntennaParams, TwoBurnOrbitTransfer, Uranus, ValidationError, type Vec3, type Vec3Flat, Vector, Vector3D, Venus, VerletBlendInterpolator, VisualizationHelpers, type Watts, Waypoint, type WaypointData, ZoomValue, acoth, acsch, angularDiameter, angularDistance, angularVelocityOfEarth, array2d, asec2rad, asech, azel2uv, bodyTypeLookup, boresightFrameFromAzElRoll, cKmPerMs, cKmPerSec, cMPerSec, calcGmst, calcIncFromAz, calcInertAz, calculateFspl, calculatePropagationDelay, cappedScreeningCovarianceFromTle, clamp, concat, copySign, covariance, createCovarianceFromTle, createSampleCovarianceFromTle, createVec, csch, dbmToDbw, dbwToDbm, dbwToWatts, deg2rad, derivative, dopplerFactor, earthGravityParam, ecef2eci, ecef2enu, ecef2rae, ecefRad2rae, eci2ecef, eci2lla, eci2rae, enu2rf, estimateRcs, estimateVmagFromRcs, evalPoly, factorial, gamma, getDayOfYear, getDegLat, getDegLon, getRadLat, getRadLon, groundTrackStateVector, halfPi, isLeapYear, jacobian, jday, linearDistance, linearInterpolate, lla2ecef, lla2eci, lla2sez, llaRad2ecef, log10, mag2db, masec2rad, matchHalfPlane, mean, msec2sec, newtonM, newtonNu, normalizeAngle, observationDerivative, observationNoiseFromSigmas, parseCenterBody, perigeeSpeed, rad2deg, radecToPosition, radecToVelocity, rae2ecef, rae2eci, rae2enu, rae2raeOffBoresight, rae2ruv, rae2sez, relativeVelocity, rv2tle, scaleAndClampRicSigmas, sec2day, sec2deg, sec2min, sech, secondsPerDay, secondsPerSiderealDay, secondsPerWeek, semimajorAxisFromMeanMotion, sez2rae, sign, spaceObjType2Str, std, temp4, toPrecision, ttasec2rad, uv2azel, wattsToDbw, wrapAngle, x2o3 };