ootk 7.0.2 → 7.1.0

package/dist/main.cjs

@@ -1,5 +1,9 @@
 'use strict';
 
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.23_tsx@4.23.1_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/errors/index.ts
 var OotkError = class extends Error {
   constructor(message) {
@@ -23,6 +27,8 @@ var ValidationError = class extends OotkError {
     this.value = value;
     this.name = "ValidationError";
   }
+  field;
+  value;
 };
 var ParseError = class extends OotkError {
   /**
@@ -37,6 +43,8 @@ var ParseError = class extends OotkError {
     this.line = line;
     this.name = "ParseError";
   }
+  format;
+  line;
 };
 var PropagationError = class extends OotkError {
   /**
@@ -49,6 +57,7 @@ var PropagationError = class extends OotkError {
     this.epoch = epoch;
     this.name = "PropagationError";
   }
+  epoch;
 };
 var OrbitDeterminationError = class extends OotkError {
   /**
@@ -61,6 +70,7 @@ var OrbitDeterminationError = class extends OotkError {
     this.algorithm = algorithm;
     this.name = "OrbitDeterminationError";
   }
+  algorithm;
 };
 
 // src/enums/AngularDiameterMethod.ts
@@ -155,6 +165,7 @@ var SensorType = /* @__PURE__ */ ((SensorType2) => {
   SensorType2["LASER_RANGING"] = "LASER_RANGING";
   SensorType2["PASSIVE_RF"] = "PASSIVE_RF";
   SensorType2["BISTATIC_RADIO_TELESCOPE"] = "BISTATIC_RADIO_TELESCOPE";
+  SensorType2["TT_C_ANTENNA"] = "TT_C_ANTENNA";
   return SensorType2;
 })(SensorType || {});
 
@@ -225,6 +236,7 @@ var SpaceObjectType = /* @__PURE__ */ ((SpaceObjectType2) => {
   SpaceObjectType2[SpaceObjectType2["DWARF_PLANET"] = 36] = "DWARF_PLANET";
   SpaceObjectType2[SpaceObjectType2["MOON"] = 37] = "MOON";
   SpaceObjectType2[SpaceObjectType2["DYNAMIC_GROUND_OBJECT"] = 38] = "DYNAMIC_GROUND_OBJECT";
+  SpaceObjectType2[SpaceObjectType2["ASTEROID"] = 39] = "ASTEROID";
   SpaceObjectType2[SpaceObjectType2["MAX_SPACE_OBJECT_TYPE"] = 40] = "MAX_SPACE_OBJECT_TYPE";
   return SpaceObjectType2;
 })(SpaceObjectType || {});
@@ -278,6 +290,7 @@ var Epoch = class {
       throw new ValidationError("Epoch posix time must be a valid number", "posix", posix);
     }
   }
+  posix;
   toString() {
     return this.toDateTime().toISOString();
   }
@@ -440,7 +453,8 @@ function matchHalfPlane(angle, match) {
   return Math.abs(d1) < Math.abs(d2) ? a1 : a2;
 }
 function wrapAngle(theta) {
-  const result = (theta + Math.PI) % (2 * Math.PI) - Math.PI;
+  const tau = 2 * Math.PI;
+  const result = ((theta + Math.PI) % tau + tau) % tau - Math.PI;
   if (result === -Math.PI) {
     return Math.PI;
   }
@@ -449,7 +463,7 @@ function wrapAngle(theta) {
 function angularDistanceCosine_(lam1, phi1, lam2, phi2) {
   const a = Math.sin(phi1) * Math.sin(phi2);
   const b = Math.cos(phi1) * Math.cos(phi2) * Math.cos(lam2 - lam1);
-  return Math.acos(a + b);
+  return Math.acos(Math.min(1, Math.max(-1, a + b)));
 }
 function angularDistanceHaversine_(lam1, phi1, lam2, phi2) {
   const dlam = lam2 - lam1;
@@ -634,6 +648,7 @@ var spaceObjTypeStrMap_ = {
   [36 /* DWARF_PLANET */]: "Dwarf Planet",
   [37 /* MOON */]: "Moon",
   [38 /* DYNAMIC_GROUND_OBJECT */]: "Dynamic Ground Object",
+  [39 /* ASTEROID */]: "Asteroid",
   [40 /* MAX_SPACE_OBJECT_TYPE */]: "Max Space Object Type"
 };
 var spaceObjType2Str = (spaceObjType) => spaceObjTypeStrMap_[spaceObjType] || "Unknown";
@@ -1815,6 +1830,8 @@ var EpochGPS = class _EpochGPS {
       throw new ValidationError("GPS seconds must be between 0 and 604799", "seconds", seconds);
     }
   }
+  week;
+  seconds;
   /** Cached GPS reference epoch (1980-01-06T00:00:00.000Z) */
   static reference_ = null;
   /**
@@ -1950,6 +1967,7 @@ var Vector = class _Vector {
     this.elements = elements;
     this.length = elements.length;
   }
+  elements;
   /**
    * The length of the vector.
    */
@@ -2713,6 +2731,9 @@ var Vector3D = class _Vector3D {
     this.y = y;
     this.z = z;
   }
+  x;
+  y;
+  z;
   /**
    * Create a new Vector3D object from the first three elements of a Vector
    * object.
@@ -3220,6 +3241,131 @@ var Sgp4Error = class _Sgp4Error extends Error {
   }
 };
 
+// src/sgp4/sgp4-wasm-backend.ts
+var WASM_KEY_FAILED = -1n;
+var defineHidden_ = (obj, key, value) => {
+  Object.defineProperty(obj, key, {
+    value,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+};
+var backend = null;
+var satKeyCache = /* @__PURE__ */ new Map();
+var syntheticSatnumCounter = 0;
+var wasmAttachedCount = 0;
+var wasmFallbackCount = 0;
+var SYNTHETIC_SATNUM_LETTERS = "VWXYZ";
+var synthesizeSatnum_ = () => {
+  const n = syntheticSatnumCounter++;
+  const letterIdx = Math.floor(n / 1e4);
+  if (letterIdx >= SYNTHETIC_SATNUM_LETTERS.length) {
+    return null;
+  }
+  return `${SYNTHETIC_SATNUM_LETTERS[letterIdx]}${(n % 1e4).toString().padStart(4, "0")}`;
+};
+var tryAddWithSyntheticSatnum_ = (wasm, line1, line2) => {
+  const satnumField = line1.substring(2, 7);
+  const classification = line1.charAt(7);
+  const isSatnumMeaningless = satnumField.trim() === "" || satnumField === "00000";
+  const isNonStandardClassification = classification !== "U" && classification !== "C" && classification !== "S";
+  if (!isSatnumMeaningless && !isNonStandardClassification) {
+    return null;
+  }
+  const satnum = synthesizeSatnum_();
+  if (satnum === null) {
+    return null;
+  }
+  const syntheticLine1 = `${line1.slice(0, 2)}${satnum}U${line1.slice(8)}`;
+  const syntheticLine2 = `${line2.slice(0, 2)}${satnum}${line2.slice(7)}`;
+  try {
+    const satKey = wasm.addSat(syntheticLine1, syntheticLine2);
+    wasm.initSats([satKey]);
+    return satKey;
+  } catch {
+    return null;
+  }
+};
+var setSgp4WasmBackend = (wasm) => {
+  if (!wasm.isLoaded) {
+    throw new Error("Sgp4 wasm backend must be loaded before use. Call load() first.");
+  }
+  backend = wasm;
+};
+var clearSgp4WasmBackend = () => {
+  backend = null;
+  satKeyCache.clear();
+  syntheticSatnumCounter = 0;
+  wasmAttachedCount = 0;
+  wasmFallbackCount = 0;
+};
+var getSgp4WasmBackendStats = () => ({
+  attached: wasmAttachedCount,
+  fallback: wasmFallbackCount
+});
+var isSgp4WasmBackendActive = () => backend !== null;
+var stashTleLines = (satrec, line1, line2) => {
+  defineHidden_(satrec, "wasmTleLine1", line1);
+  defineHidden_(satrec, "wasmTleLine2", line2);
+};
+var ensureSatKey_ = (wasm, satrec) => {
+  const existing = satrec.wasmSatKey;
+  if (existing !== void 0) {
+    return existing > 0n ? existing : null;
+  }
+  const line1 = satrec.wasmTleLine1;
+  const line2 = satrec.wasmTleLine2;
+  if (!line1 || !line2) {
+    defineHidden_(satrec, "wasmSatKey", WASM_KEY_FAILED);
+    wasmFallbackCount++;
+    return null;
+  }
+  const cacheKey = `${line1}
+${line2}`;
+  const cached = satKeyCache.get(cacheKey);
+  if (cached !== void 0) {
+    defineHidden_(satrec, "wasmSatKey", cached);
+    return cached;
+  }
+  try {
+    const satKey = wasm.addSat(line1, line2);
+    wasm.initSats([satKey]);
+    satKeyCache.set(cacheKey, satKey);
+    defineHidden_(satrec, "wasmSatKey", satKey);
+    wasmAttachedCount++;
+    return satKey;
+  } catch {
+    const syntheticKey = tryAddWithSyntheticSatnum_(wasm, line1, line2);
+    if (syntheticKey !== null) {
+      satKeyCache.set(cacheKey, syntheticKey);
+      defineHidden_(satrec, "wasmSatKey", syntheticKey);
+      wasmAttachedCount++;
+      return syntheticKey;
+    }
+    defineHidden_(satrec, "wasmSatKey", WASM_KEY_FAILED);
+    wasmFallbackCount++;
+    return null;
+  }
+};
+var tryPropagateWasm = (satrec, tsince) => {
+  if (!backend || satrec.init) {
+    return null;
+  }
+  const satKey = ensureSatKey_(backend, satrec);
+  if (satKey === null) {
+    return null;
+  }
+  const result = backend.propagateOnePosVelFast(satKey, tsince);
+  if (result.err !== 0) {
+    return { position: false, velocity: false };
+  }
+  return {
+    position: result.position,
+    velocity: result.velocity
+  };
+};
+
 // src/sgp4/sgp4.ts
 var fasx2 = 0.13130908;
 var fasx4 = 2.8843198;
@@ -3234,6 +3380,42 @@ var stepp = 720;
 var stepn = -720;
 var step2 = 259200;
 var Sgp4 = 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) {
+    setSgp4WasmBackend(wasm);
+  }
+  /**
+   * Restores the pure-TypeScript SGP4 implementation.
+   */
+  static clearWasmBackend() {
+    clearSgp4WasmBackend();
+  }
+  /**
+   * Whether propagation is currently routed through a wasm backend.
+   */
+  static get isWasmBackendActive() {
+    return isSgp4WasmBackendActive();
+  }
+  /**
+   * 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() {
+    return getSgp4WasmBackendStats();
+  }
   /*
    * -----------------------------------------------------------------------------
    *
@@ -3393,6 +3575,7 @@ var Sgp4 = class _Sgp4 {
       xno: satrec.no,
       xnodeo: satrec.nodeo
     });
+    stashTleLines(satrec, tleLine1, tleLine2);
     return satrec;
   }
   static createSatrecFromOmm(omm, whichconst = "wgs72" /* wgs72 */, opsmode = "i" /* IMPROVED */) {
@@ -3910,6 +4093,10 @@ var Sgp4 = class _Sgp4 {
    *----------------------------------------------------------------------------
    */
   static propagate(satrec, tsince) {
+    const wasmResult = tryPropagateWasm(satrec, tsince);
+    if (wasmResult !== null) {
+      return wasmResult;
+    }
     const { xke, j2, j3oj2, vkmpersec } = satrec;
     satrec.t = tsince;
     satrec.error = 0 /* NO_ERROR */;
@@ -6320,7 +6507,7 @@ function uv2azel(u, v, coneHalfAngle) {
     throw new ValidationError("v must be between -1 and 1", "v", v);
   }
   const alpha = Math.asin(u);
-  const beta = Math.asin(v);
+  const beta = Math.asin(0 - v);
   const az = alpha / 90 * (coneHalfAngle * RAD2DEG);
   const el = beta / 90 * (coneHalfAngle * RAD2DEG);
   return { az, el };
@@ -6354,6 +6541,8 @@ var StateCovariance = class _StateCovariance {
     this.matrix = matrix;
     this.frame = frame;
   }
+  matrix;
+  frame;
   // / Create a new [StateCovariance] object from 1-sigma values.
   static fromSigmas(sigmas, frame) {
     const n = sigmas.length;
@@ -6556,7 +6745,7 @@ var ClassicalElements = class _ClassicalElements {
     }
     const pos = state.position;
     const vel = state.velocity;
-    const a = state.semimajorAxis;
+    const a = 1 / (2 / pos.magnitude() - vel.magnitude() ** 2 / mu);
     const eVecA = pos.scale(vel.magnitude() ** 2 - mu / pos.magnitude());
     const eVecB = vel.scale(pos.dot(vel));
     const eVec = eVecA.subtract(eVecB).scale(1 / mu);
@@ -6685,7 +6874,7 @@ var ClassicalElements = class _ClassicalElements {
    */
   getOrbitRegime() {
     const n = this.revsPerDay;
-    const p = this.period * sec2min;
+    const p = this.period;
     if (n >= 0.99 && n <= 1.01 && this.eccentricity < 0.01) {
       return "Geosynchronous Orbit" /* GEO */;
     }
@@ -6753,13 +6942,14 @@ var ClassicalElements = class _ClassicalElements {
     let maInit = eaInit - this.eccentricity * Math.sin(eaInit);
     maInit = matchHalfPlane(maInit, eaInit);
     const maFinal = (maInit + n * delta) % TAU;
-    let eaFinal = maFinal;
-    for (let iter = 0; iter < 32; iter++) {
-      const eaTemp = maFinal + this.eccentricity * Math.sin(eaFinal);
-      if (Math.abs(eaTemp - eaFinal) < 1e-12) {
+    const ecc = this.eccentricity;
+    let eaFinal = ecc > 0.8 ? Math.PI * Math.sign(maFinal || 1) : maFinal;
+    for (let iter = 0; iter < 50; iter++) {
+      const step = (eaFinal - ecc * Math.sin(eaFinal) - maFinal) / (1 - ecc * Math.cos(eaFinal));
+      eaFinal -= step;
+      if (Math.abs(step) < 1e-12) {
         break;
       }
-      eaFinal = eaTemp;
     }
     const cosEaFinal = Math.cos(eaFinal);
     let vFinal = Math.acos(clamp((cosEaFinal - this.eccentricity) / (1 - this.eccentricity * cosEaFinal), -1, 1));
@@ -7189,13 +7379,21 @@ var GroundObject = class extends BaseObject {
   }
   /**
    * 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.
    */
   eci(date = /* @__PURE__ */ new Date()) {
     const { gmst } = calcGmst(date);
-    return lla2eci(this.toGeodetic(), gmst);
+    return ecef2eci(llaRad2ecef(this.llaRad()), gmst);
   }
   /**
    * Returns the latitude, longitude, and altitude of the GroundObject.
@@ -7236,18 +7434,16 @@ var GroundObject = class extends BaseObject {
   }
   /**
    * 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
    */
   toJ2000(date = /* @__PURE__ */ new Date()) {
-    const { gmst } = calcGmst(date);
-    const position = lla2eci(this.llaRad(), gmst);
-    return new J2000(
-      EpochUTC.fromDateTime(date),
-      new Vector3D(position.x, position.y, position.z),
-      new Vector3D(0, 0, 0)
-    );
+    return this.toGeodetic().toITRF(EpochUTC.fromDateTime(date)).toJ2000();
   }
   // ==================== Component Management ====================
   /**
@@ -7794,7 +7990,7 @@ var TEME = class _TEME extends StateVector {
   }
 };
 
-// node_modules/astronomy-engine/esm/astronomy.js
+// node_modules/.pnpm/astronomy-engine@2.1.19/node_modules/astronomy-engine/esm/astronomy.js
 var C_AUDAY = 173.1446326846693;
 var KM_PER_AU2 = 14959787069098932e-8;
 var DEG2RAD2 = 0.017453292519943295;
@@ -9861,7 +10057,7 @@ function CalcPluto(time, helio) {
     r = ra.mul(1 - ramp).add(rb.mul(ramp));
     v = va.mul(1 - ramp).add(vb.mul(ramp));
   }
-  if (helio) {
+  {
     if (!bary)
       bary = new major_bodies_t(time.tt);
     r = r.sub(bary.Sun.r);
@@ -9874,7 +10070,7 @@ function HelioVector(body, date) {
   if (body in vsop)
     return CalcVsop(vsop[body], time);
   if (body === Body.Pluto) {
-    const p = CalcPluto(time, true);
+    const p = CalcPluto(time);
     return new Vector2(p.x, p.y, p.z, time);
   }
   if (body === Body.Sun)
@@ -9970,38 +10166,6 @@ function GeoVector(body, date, aberration) {
 function ExportState(terse, time) {
   return new StateVector2(terse.r.x, terse.r.y, terse.r.z, terse.v.x, terse.v.y, terse.v.z, time);
 }
-function BaryState(body, date) {
-  const time = MakeTime(date);
-  if (body === Body.SSB) {
-    return new StateVector2(0, 0, 0, 0, 0, 0, time);
-  }
-  if (body === Body.Pluto) {
-    return CalcPluto(time, false);
-  }
-  const bary = new major_bodies_t(time.tt);
-  switch (body) {
-    case Body.Sun:
-      return ExportState(bary.Sun, time);
-    case Body.Jupiter:
-      return ExportState(bary.Jupiter, time);
-    case Body.Saturn:
-      return ExportState(bary.Saturn, time);
-    case Body.Uranus:
-      return ExportState(bary.Uranus, time);
-    case Body.Neptune:
-      return ExportState(bary.Neptune, time);
-    case Body.Moon:
-    case Body.EMB:
-      const earth = CalcVsopPosVel(vsop[Body.Earth], time.tt);
-      const state = body === Body.Moon ? GeoMoonState(time) : GeoEmbState(time);
-      return new StateVector2(state.x + bary.Sun.r.x + earth.r.x, state.y + bary.Sun.r.y + earth.r.y, state.z + bary.Sun.r.z + earth.r.z, state.vx + bary.Sun.v.x + earth.v.x, state.vy + bary.Sun.v.y + earth.v.y, state.vz + bary.Sun.v.z + earth.v.z, time);
-  }
-  if (body in vsop) {
-    const planet = CalcVsopPosVel(vsop[body], time.tt);
-    return new StateVector2(bary.Sun.r.x + planet.r.x, bary.Sun.r.y + planet.r.y, bary.Sun.r.z + planet.r.z, bary.Sun.v.x + planet.v.x, bary.Sun.v.y + planet.v.y, bary.Sun.v.z + planet.v.z, time);
-  }
-  throw `BaryState: Unsupported body "${body}"`;
-}
 function HelioState(body, date) {
   const time = MakeTime(date);
   switch (body) {
@@ -10021,7 +10185,7 @@ function HelioState(body, date) {
       const planet = CalcVsopPosVel(vsop[body], time.tt);
       return ExportState(planet, time);
     case Body.Pluto:
-      return CalcPluto(time, true);
+      return CalcPluto(time);
     case Body.Moon:
     case Body.EMB:
       const earth = CalcVsopPosVel(vsop.Earth, time.tt);
@@ -10342,6 +10506,11 @@ function SearchRiseSet(body, observer, direction, dateStart, limitDays, metersAb
   const altitude = dip - REFRACTION_NEAR_HORIZON * atmos.density;
   return InternalSearchAltitude(body, observer, direction, dateStart, limitDays, body_radius_au, altitude);
 }
+function SearchAltitude(body, observer, direction, dateStart, limitDays, altitude) {
+  if (!Number.isFinite(altitude) || altitude < -90 || altitude > 90)
+    throw `Invalid altitude angle: ${altitude}`;
+  return InternalSearchAltitude(body, observer, direction, dateStart, limitDays, 0, altitude);
+}
 var AscentInfo = class {
   constructor(tx, ty, ax, ay) {
     this.tx = tx;
@@ -10604,7 +10773,9 @@ var CelestialBody = class 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, date = /* @__PURE__ */ new Date(), minElevation = 0) {
@@ -10613,8 +10784,10 @@ var CelestialBody = class extends BaseObject {
     }
     const obs = new Observer(observer.lat, observer.lon, observer.alt * 1e3);
     const time = MakeTime(date);
-    const riseTime = SearchRiseSet(this.astronomyBody_, obs, 1, time, 1, minElevation);
-    const setTime = SearchRiseSet(this.astronomyBody_, obs, -1, time, 1, minElevation);
+    const body = this.astronomyBody_;
+    const search = (direction) => minElevation === 0 ? SearchRiseSet(body, obs, direction, time, 1) : SearchAltitude(body, obs, direction, time, 1, minElevation);
+    const riseTime = search(1);
+    const setTime = search(-1);
     let transitTime = null;
     if (riseTime && setTime) {
       const riseMs = riseTime.date.getTime();
@@ -10633,14 +10806,17 @@ var CelestialBody = class extends BaseObject {
   }
   /**
    * 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) {
+  getAngularDiameter(observerPos, date = /* @__PURE__ */ new Date()) {
     if (!this.radius) {
       throw new Error(`${this.name} does not have a defined radius`);
     }
-    const distance = observerPos.subtract(this.eci()).magnitude();
+    const distance = observerPos.subtract(this.eci(date)).magnitude();
     return 2 * Math.atan(this.radius / distance);
   }
   /**
@@ -10781,16 +10957,16 @@ var SunBody = class _SunBody extends CelestialBody {
     return this.geoVectorToKm(Body.Sun, date);
   }
   /**
-   * 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 = /* @__PURE__ */ new Date()) {
-    const pos = this.eci(date);
-    const distance = pos.magnitude();
-    const lightTimeSec = distance / cKmPerSec;
-    const adjustedDate = new Date(date.getTime() - lightTimeSec * 1e3);
-    return this.eci(adjustedDate);
+    return this.eci(date);
   }
   /**
    * Gets the Sun's position in heliocentric coordinates.
@@ -10855,8 +11031,13 @@ var SunBody = class _SunBody extends CelestialBody {
   // ==================== Satellite Shadow Methods ====================
   /**
    * 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';
@@ -10865,14 +11046,8 @@ var SunBody = 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');
    *
@@ -10948,11 +11123,12 @@ var SunBody = class _SunBody extends CelestialBody {
   }
   /**
    * 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) {
-    const sunPos = this.eci();
+  diameter(obsPos, date = /* @__PURE__ */ new Date()) {
+    const sunPos = this.eci(date);
     const distance = obsPos.subtract(sunPos).magnitude();
     return 2 * Math.asin(_SunBody.RADIUS / distance);
   }
@@ -10997,7 +11173,7 @@ var SunBody = class _SunBody extends CelestialBody {
     if (isNaN(lon)) {
       throw new Error("longitude missing");
     }
-    const date = dateVal instanceof Date ? dateVal : new Date(dateVal);
+    const date = new Date(dateVal instanceof Date ? dateVal.getTime() : dateVal);
     if (isUtc) {
       date.setUTCHours(12, 0, 0, 0);
     } else {
@@ -11021,15 +11197,19 @@ var SunBody = class _SunBody extends CelestialBody {
   }
   /**
    * 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, date = /* @__PURE__ */ new Date(), minElevation = -0.833) {
     const obs = new Observer(observer.lat, observer.lon, observer.alt * 1e3);
     const time = MakeTime(date);
-    const sunrise = SearchRiseSet(Body.Sun, obs, 1, time, 1, minElevation);
-    const sunset = SearchRiseSet(Body.Sun, obs, -1, time, 1, minElevation);
+    const sunrise = SearchAltitude(Body.Sun, obs, 1, time, 1, minElevation);
+    const sunset = SearchAltitude(Body.Sun, obs, -1, time, 1, minElevation);
     return {
       sunrise: sunrise?.date ?? null,
       sunset: sunset?.date ?? null
@@ -11308,6 +11488,9 @@ var SolarRadiationPressure = class _SolarRadiationPressure extends Force {
     this.area = area;
     this.reflectCoeff = reflectCoeff;
   }
+  mass;
+  area;
+  reflectCoeff;
   // / Solar pressure _(N/m²)_;
   static _kRef = 456e-8 * KM_PER_AU ** 2;
   acceleration(state) {
@@ -11542,7 +11725,7 @@ var MoonBody = class _MoonBody extends CelestialBody {
     if (!phase) {
       phase = _MoonBody.moonCycles_[0];
     }
-    let type = "";
+    let type;
     if (next === nextNewMoon) {
       type = "newMoon";
     } else if (next === nextFirstQuarter) {
@@ -11690,6 +11873,8 @@ var ThirdBodyGravity = class _ThirdBodyGravity {
     this.moon = moon;
     this.sun = sun;
   }
+  moon;
+  sun;
   static moonGravity_(state) {
     const rMoon = Moon.eci(state.epoch.toDateTime());
     const aNum = rMoon.subtract(state.position);
@@ -12096,29 +12281,40 @@ var FormatTle = 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
    */
   static formatTleExponential(value) {
-    if (value === 0) {
+    if (value === 0 || !Number.isFinite(value)) {
       return " 00000+0";
     }
     const sign2 = value >= 0 ? " " : "-";
     const absVal = Math.abs(value);
     let exponent = Math.floor(Math.log10(absVal)) + 1;
-    let mantissa = absVal / 10 ** exponent;
-    if (mantissa >= 1) {
-      mantissa /= 10;
+    let mantissa = Math.round(absVal / 10 ** exponent * 1e5);
+    while (mantissa < 1e4) {
+      exponent--;
+      mantissa = Math.round(absVal / 10 ** exponent * 1e5);
+    }
+    while (mantissa >= 1e5) {
       exponent++;
+      mantissa = Math.round(absVal / 10 ** exponent * 1e5);
     }
-    if (mantissa < 0.1 && mantissa > 0) {
-      mantissa *= 10;
-      exponent--;
+    if (exponent < -9) {
+      return " 00000+0";
+    }
+    if (exponent > 9) {
+      return `${sign2}99999+9`;
     }
-    const mantissaStr = Math.round(mantissa * 1e5).toString().padStart(5, "0");
     const expSign = exponent >= 0 ? "+" : "-";
-    const expStr = Math.abs(exponent).toString();
-    return sign2 + mantissaStr + expSign + expStr;
+    return sign2 + mantissa.toString() + expSign + Math.abs(exponent).toString();
   }
   /**
    * Compute TLE line checksum (modulo 10 sum of digits, '-' counts as 1).
@@ -12295,20 +12491,8 @@ ${this.line2}`;
   }
   static calcElsetAge(tle1, nowInput, outputUnits = "days") {
     nowInput ??= /* @__PURE__ */ new Date();
-    const currentYearFull = nowInput.getUTCFullYear();
-    const currentYearShort = currentYearFull % 100;
-    const epochYearShort = parseInt(tle1.substring(18, 20), 10);
-    const epochDayOfYear = parseFloat(tle1.substring(20, 32));
-    let epochYearFull;
-    if (epochYearShort <= currentYearShort) {
-      epochYearFull = 2e3 + epochYearShort;
-    } else {
-      epochYearFull = 1900 + epochYearShort;
-    }
-    const epochJday = epochDayOfYear + epochYearFull * 365;
-    const currentJday = getDayOfYear(nowInput) + currentYearFull * 365;
-    const currentTime = (nowInput.getUTCHours() * 3600 + nowInput.getUTCMinutes() * 60 + nowInput.getUTCSeconds()) / 86400;
-    const daysOld = currentJday + currentTime - epochJday;
+    const epochMs = _Tle.parseEpoch_(tle1.substring(18, 32)).toDateTime().getTime();
+    const daysOld = (nowInput.getTime() - epochMs) / 864e5;
     switch (outputUnits) {
       case "hours":
         return daysOld * 24;
@@ -12991,6 +13175,8 @@ var RkCheckpoint = class {
     this.cacheState = cacheState;
     this.stepSize = stepSize;
   }
+  cacheState;
+  stepSize;
 };
 
 // src/propagator/RkResult.ts
@@ -13001,6 +13187,9 @@ var RkResult = class {
     this.error = error;
     this.newStep = newStep;
   }
+  state;
+  error;
+  newStep;
 };
 
 // src/interpolator/CubicSpline.ts
@@ -13014,6 +13203,12 @@ var CubicSpline = class {
     this.p1 = p1;
     this.m1 = m1;
   }
+  t0;
+  p0;
+  m0;
+  t1;
+  p1;
+  m1;
   // / Interpolate position at the provided time [t] _(POSIX seconds)_.
   position_(t) {
     const t2 = t * t;
@@ -13052,9 +13247,8 @@ var Interpolator = class {
    * cached value range.
    */
   inWindow(epoch) {
-    const start = this.window().start;
-    const stop = this.window().end;
-    return start <= epoch && epoch <= stop;
+    const window = this.window();
+    return window.start.posix <= epoch.posix && epoch.posix <= window.end.posix;
   }
   /*
    * Calculate the start/stop epoch between this and another [Interpolator].
@@ -13062,13 +13256,15 @@ var Interpolator = class {
    * Returns `null` if there is no overlap between interpolators.
    */
   overlap(interpolator) {
-    const x1 = this.window().start;
-    const x2 = this.window().end;
-    const y1 = interpolator.window().start;
-    const y2 = interpolator.window().end;
+    const a = this.window();
+    const b = interpolator.window();
+    const x1 = a.start.posix;
+    const x2 = a.end.posix;
+    const y1 = b.start.posix;
+    const y2 = b.end.posix;
     if (x1 <= y2 && y1 <= x2) {
-      const e1 = new EpochUTC(Math.max(x1.posix, y1.posix));
-      const e2 = new EpochUTC(Math.min(x2.posix, y2.posix));
+      const e1 = new EpochUTC(Math.max(x1, y1));
+      const e2 = new EpochUTC(Math.min(x2, y2));
       return new EpochWindow(e1, e2);
     }
     return null;
@@ -13089,6 +13285,7 @@ var CubicSplineInterpolator = class _CubicSplineInterpolator extends StateInterp
     super();
     this.splines_ = splines_;
   }
+  splines_;
   static fromEphemeris(ephemeris) {
     const splines = [];
     for (let i = 0; i < ephemeris.length - 1; i++) {
@@ -13288,6 +13485,7 @@ var VerletBlendInterpolator = class _VerletBlendInterpolator extends StateInterp
     super();
     this.ephemeris = ephemeris;
   }
+  ephemeris;
   get sizeBytes() {
     return 64 * 7 * this.ephemeris.length / 8;
   }
@@ -13483,7 +13681,7 @@ var Propagator = class {
   ephemeris(start, stop, interval = 60) {
     const output = [this.propagate(start)];
     let tempEpoch = start;
-    while (tempEpoch <= stop) {
+    while (tempEpoch.posix <= stop.posix) {
       tempEpoch = tempEpoch.roll(interval);
       output.push(this.propagate(tempEpoch));
     }
@@ -13657,6 +13855,9 @@ var RungeKuttaAdaptive = class _RungeKuttaAdaptive extends Propagator {
     this._cacheState = this.initState_;
     this.tolerance_ = Math.max(_RungeKuttaAdaptive._minTolerance, Math.abs(tolerance_));
   }
+  initState_;
+  forceModel_;
+  tolerance_;
   // / Initial state vector.
   _cacheState;
   _checkpoints = [];
@@ -13776,7 +13977,7 @@ var RungeKuttaAdaptive = class _RungeKuttaAdaptive extends Propagator {
     let tState = this.propagate(maneuver.start);
     this.forceModel_.loadManeuver(maneuver);
     const ephemeris = [tState];
-    while (tState.epoch < maneuver.stop) {
+    while (tState.epoch.posix < maneuver.stop.posix) {
       const step = Math.min(maneuver.stop.difference(tState.epoch), interval);
       tState = this.propagate(tState.epoch.roll(step));
       ephemeris.push(tState);
@@ -13785,13 +13986,13 @@ var RungeKuttaAdaptive = class _RungeKuttaAdaptive extends Propagator {
     return ephemeris;
   }
   ephemerisManeuver(start, finish, maneuvers, interval = 60) {
-    const tMvr = maneuvers.filter((mvr) => mvr.start >= start || mvr.stop <= finish);
+    const tMvr = maneuvers.filter((mvr) => mvr.start.posix >= start.posix || mvr.stop.posix <= finish.posix);
     const ephemeris = [];
-    if (tMvr[0].start > start) {
+    if (tMvr[0].start.posix > start.posix) {
       ephemeris.push(this.propagate(start));
     }
     for (const mvr of tMvr) {
-      while (this._cacheState.epoch < mvr.start) {
+      while (this._cacheState.epoch.posix < mvr.start.posix) {
         const step = Math.min(mvr.start.difference(this._cacheState.epoch), interval);
         this.propagate(this._cacheState.epoch.roll(step));
         if (this._cacheState.epoch.posix !== mvr.start.posix) {
@@ -14390,6 +14591,7 @@ var AccessWindow = class _AccessWindow {
 };
 
 // src/objects/AccessCalculator.ts
+var CIVIL_TWILIGHT_DEG = -6;
 var AccessCalculator = class _AccessCalculator {
   /** Default calculation time step in milliseconds (10 seconds) */
   static DEFAULT_STEP_MS_ = 1e4;
@@ -14530,31 +14732,20 @@ var AccessCalculator = class _AccessCalculator {
       return false;
     }
     if (constraints.requireSunlit) {
-      const eci = target.eci(date);
-      if (!eci) {
+      let satPos;
+      try {
+        satPos = target.toJ2000(date).position;
+      } catch {
         return false;
       }
       const epoch = EpochUTC.fromDateTime(date);
-      const satPos = new Vector3D(
-        eci.position.x,
-        eci.position.y,
-        eci.position.z
-      );
       if (Sun.shadow(epoch, satPos)) {
         return false;
       }
     }
     if (constraints.requireObserverDark) {
-      const lla = observer.lla();
-      const altMeters = lla.alt * 1e3;
-      const sunTimes = Sun.getTimes(date, lla.lat, lla.lon, altMeters);
-      const currentTime = date.getTime();
-      const civilDusk = sunTimes.civilDusk?.getTime();
-      const civilDawn = sunTimes.civilDawn?.getTime();
-      if (civilDusk && civilDawn) {
-        if (currentTime >= civilDawn && currentTime <= civilDusk) {
-          return false;
-        }
+      if (Sun.getAzEl(observer, date, false).el >= CIVIL_TWILIGHT_DEG) {
+        return false;
       }
     }
     return true;
@@ -14734,38 +14925,35 @@ var DynamicGroundObject = class _DynamicGroundObject extends GroundObject {
   }
   /**
    * 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) {
-    const lla = this.getLLA(time);
-    if (!lla) {
+    const ecef = this.getEcef(time);
+    if (!ecef) {
       return null;
     }
-    const llaRad = {
-      lat: lla.lat * DEG2RAD,
-      lon: lla.lon * DEG2RAD,
-      alt: lla.alt
-    };
     const { gmst } = calcGmst(time);
-    return lla2eci(llaRad, gmst);
+    return ecef2eci(ecef, gmst);
   }
   /**
    * 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
    */
   getJ2000(time) {
-    const eci = this.getEci(time);
-    if (!eci) {
+    const geodetic = this.getGeodetic(time);
+    if (!geodetic) {
       return null;
     }
-    return new J2000(
-      EpochUTC.fromDateTime(time),
-      new Vector3D(eci.x, eci.y, eci.z),
-      new Vector3D(0, 0, 0)
-    );
+    return geodetic.toITRF(EpochUTC.fromDateTime(time)).toJ2000();
   }
   /**
    * Converts position at a specific time to Geodetic coordinates.
@@ -16125,10 +16313,17 @@ var RAE = class _RAE {
     this.azRateRad = azRateRad;
     this.elRateRad = elRateRad;
   }
+  epoch;
+  rng;
+  azRad;
+  elRad;
+  rngRate;
+  azRateRad;
+  elRateRad;
   // / Create a new [Razel] object, using degrees for the angular values.
   static fromDegrees(epoch, range, azimuth, elevation, rangeRate, azimuthRate, elevationRate) {
-    const azimuthRateRad = azimuthRate ? azimuthRate * DEG2RAD : void 0;
-    const elevationRateRad = elevationRate ? elevationRate * DEG2RAD : void 0;
+    const azimuthRateRad = typeof azimuthRate === "number" ? azimuthRate * DEG2RAD : void 0;
+    const elevationRateRad = typeof elevationRate === "number" ? elevationRate * DEG2RAD : void 0;
     return new _RAE(
       epoch,
       range,
@@ -16201,14 +16396,14 @@ var RAE = class _RAE {
    * @returns The azimuth rate in degrees per second, or undefined if it is not available.
    */
   get azRate() {
-    return this.azRateRad ? this.azRateRad * RAD2DEG : void 0;
+    return typeof this.azRateRad === "number" ? this.azRateRad * RAD2DEG : void 0;
   }
   /**
    * Gets the elevation rate in degrees per second.
    * @returns The elevation rate in degrees per second, or undefined if the elevation rate is not set.
    */
   get elRate() {
-    return this.elRateRad ? this.elRateRad * RAD2DEG : void 0;
+    return typeof this.elRateRad === "number" ? this.elRateRad * RAD2DEG : void 0;
   }
   toString() {
     return [
@@ -16380,13 +16575,13 @@ var KeplerPropagator = class extends Propagator {
     return [this.cacheState_];
   }
   ephemerisManeuver(start, finish, maneuvers, interval = 60) {
-    const tMvr = maneuvers.slice(0).filter((mvr) => mvr.center >= start || mvr.center <= finish);
+    const tMvr = maneuvers.slice(0).filter((mvr) => mvr.center.posix >= start.posix && mvr.center.posix <= finish.posix);
     const ephemeris = [];
-    if (tMvr[0].start > start) {
+    if (tMvr.length === 0 || tMvr[0].start.posix > start.posix) {
       ephemeris.push(this.propagate(start));
     }
     for (const mvr of tMvr) {
-      while (this.cacheState_.epoch < mvr.center) {
+      while (this.cacheState_.epoch.posix < mvr.center.posix) {
         const step = Math.min(mvr.center.difference(this.cacheState_.epoch), interval);
         this.propagate(this.cacheState_.epoch.roll(step));
         if (this.cacheState_.epoch.posix !== mvr.center.posix) {
@@ -16395,7 +16590,7 @@ var KeplerPropagator = class extends Propagator {
       }
       ephemeris.push(...this.maneuver(mvr));
     }
-    while (this.cacheState_.epoch < finish) {
+    while (this.cacheState_.epoch.posix < finish.posix) {
       const step = Math.min(finish.difference(this.cacheState_.epoch), interval);
       this.propagate(this.cacheState_.epoch.roll(step));
       ephemeris.push(this.cacheState_);
@@ -16411,6 +16606,7 @@ var KeplerPropagator = class extends Propagator {
   }
   restore(index) {
     this.cacheState_ = this.checkpoints_[index];
+    this.elements_ = this.cacheState_.toClassicalElements();
   }
 };
 
@@ -16434,6 +16630,11 @@ var RungeKutta4Propagator = class extends Propagator {
     this.checkpoints_ = checkpoints_;
     this.stepSize_ = Math.abs(stepSize_);
   }
+  initState_;
+  forceModel_;
+  stepSize_;
+  cacheState_;
+  checkpoints_;
   // / Set the integrator step size to the provided number of [seconds].
   setStepSize(seconds) {
     this.stepSize_ = Math.abs(seconds);
@@ -16443,13 +16644,13 @@ var RungeKutta4Propagator = class extends Propagator {
     this.forceModel_ = forceModel;
   }
   ephemerisManeuver(start, finish, maneuvers, interval = 60) {
-    const tMvr = maneuvers.slice(0).filter((mvr) => mvr.start <= finish && mvr.stop >= start);
+    const tMvr = maneuvers.slice(0).filter((mvr) => mvr.start.posix <= finish.posix && mvr.stop.posix >= start.posix);
     const ephemeris = [];
-    if (tMvr.length === 0 || tMvr[0].start > start) {
+    if (tMvr.length === 0 || tMvr[0].start.posix > start.posix) {
       ephemeris.push(this.propagate(start));
     }
     for (const mvr of tMvr) {
-      while (this.cacheState_.epoch < mvr.start) {
+      while (this.cacheState_.epoch.posix < mvr.start.posix) {
         const step = Math.min(mvr.start.difference(this.cacheState_.epoch), interval);
         this.propagate(this.cacheState_.epoch.roll(step));
         if (this.cacheState_.epoch.posix !== mvr.start.posix) {
@@ -16473,7 +16674,7 @@ var RungeKutta4Propagator = class extends Propagator {
     let tState = this.propagate(maneuver.start);
     this.forceModel_.loadManeuver(maneuver);
     const ephemeris = [tState];
-    while (tState.epoch < maneuver.stop) {
+    while (tState.epoch.posix < maneuver.stop.posix) {
       const step = Math.min(maneuver.stop.difference(tState.epoch), interval);
       tState = this.propagate(tState.epoch.roll(step));
       ephemeris.push(tState);
@@ -16545,6 +16746,7 @@ var Sgp4Propagator = class extends Propagator {
     this.tle_ = tle_;
     this.cacheState_ = tle_.state.toJ2000();
   }
+  tle_;
   cacheState_;
   checkpoints_ = [];
   /**
@@ -17028,8 +17230,13 @@ var Satellite = class _Satellite extends SpaceObject {
     return rae.az;
   }
   /**
-   * 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.
@@ -17040,14 +17247,18 @@ var Satellite = class _Satellite extends SpaceObject {
     if (!rae) {
       return null;
     }
-    const rae2 = this.rae(observer, new Date(date.getTime() + 1e3));
-    if (!rae2) {
+    const halfStepMs = 500;
+    const raeBefore = this.rae(observer, new Date(date.getTime() - halfStepMs));
+    const raeAfter = this.rae(observer, new Date(date.getTime() + halfStepMs));
+    if (!raeBefore || !raeAfter) {
       return null;
     }
+    const dt = 2 * halfStepMs / 1e3;
+    const rangeRate = (raeAfter.rng - raeBefore.rng) / dt;
+    const dAz = ((raeAfter.az - raeBefore.az + 180) % 360 + 360) % 360 - 180;
+    const azimuthRate = dAz / dt * DEG2RAD;
+    const elevationRate = (raeAfter.el - raeBefore.el) / dt * DEG2RAD;
     const epoch = new EpochUTC(date.getTime() / 1e3);
-    const rangeRate = rae2.rng - rae.rng;
-    const azimuthRate = rae2.az - rae.az;
-    const elevationRate = rae2.el - rae.el;
     return new RAE(
       epoch,
       rae.rng,
@@ -17711,11 +17922,12 @@ var Satellite = 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.
@@ -17758,11 +17970,12 @@ var Satellite = class _Satellite extends SpaceObject {
    * ```
    */
   getSunStatus(date = /* @__PURE__ */ new Date()) {
-    const pv = this.eci(date);
-    if (!pv) {
+    let satPos;
+    try {
+      satPos = this.toJ2000(date).position;
+    } catch {
       return -1 /* UNKNOWN */;
     }
-    const satPos = new Vector3D(pv.position.x, pv.position.y, pv.position.z);
     const sunPos = Sun.eci(date);
     const ratio = Sun.lightingRatio(satPos, sunPos);
     if (ratio === 0) {
@@ -18230,6 +18443,43 @@ var FieldOfView = class _FieldOfView {
     const targetDir = direction.normalize();
     return this.isDirectionWithinCone(targetDir);
   }
+  /**
+   * 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, radialFraction = 1) {
+    const x = radialFraction * this.halfAngleRad_ * Math.cos(t);
+    const y = radialFraction * this.minorHalfAngleRad_ * Math.sin(t);
+    const theta = Math.hypot(x, y);
+    const { b, u, v } = this.boresightFrame_;
+    if (theta < EPS) {
+      return b;
+    }
+    const cosTheta = Math.cos(theta);
+    const sinTheta = Math.sin(theta);
+    const rx = x / theta;
+    const ry = y / theta;
+    return new Vector3D(
+      cosTheta * b.x + sinTheta * (rx * u.x + ry * v.x),
+      cosTheta * b.y + sinTheta * (rx * u.y + ry * v.y),
+      cosTheta * b.z + sinTheta * (rx * u.z + ry * v.z)
+    );
+  }
   /**
    * Gets the effective minimum elevation at a given azimuth.
    * Considers all applicable elevation masks and returns the most restrictive.
@@ -18639,13 +18889,13 @@ var VisualizationHelpers = class {
     const points = [];
     for (let i = 0; i < samples; i++) {
       const phi = 2 * Math.PI * i / samples;
-      const theta = Math.sqrt(
-        (fov.halfAngle * Math.cos(phi)) ** 2 + (fov.minorHalfAngle * Math.sin(phi)) ** 2
-      ) * DEG2RAD;
+      const x = fov.halfAngle * Math.cos(phi) * DEG2RAD;
+      const y = fov.minorHalfAngle * Math.sin(phi) * DEG2RAD;
+      const theta = Math.hypot(x, y);
       const cosTheta = Math.cos(theta);
       const sinTheta = Math.sin(theta);
-      const cosPhi = Math.cos(phi);
-      const sinPhi = Math.sin(phi);
+      const cosPhi = theta > 0 ? x / theta : 1;
+      const sinPhi = theta > 0 ? y / theta : 0;
       const dir = {
         x: b.x * cosTheta + u.x * sinTheta * cosPhi + v.x * sinTheta * sinPhi,
         y: b.y * cosTheta + u.y * sinTheta * cosPhi + v.y * sinTheta * sinPhi,
@@ -18835,7 +19085,7 @@ var PlanetBody = class _PlanetBody extends CelestialBody {
    */
   velocity(date = /* @__PURE__ */ new Date()) {
     const time = MakeTime(date);
-    const state = BaryState(this.planetData_.body, time);
+    const state = HelioState(this.planetData_.body, time);
     return new Vector3D(
       state.vx * AU_PER_DAY_TO_KM_PER_S,
       state.vy * AU_PER_DAY_TO_KM_PER_S,
@@ -18914,7 +19164,7 @@ var EphemerisBody = class _EphemerisBody extends CelestialBody {
     if (!params.ephemeris || params.ephemeris.length === 0) {
       throw new Error("Ephemeris array cannot be empty");
     }
-    let spaceObjectType = 0 /* UNKNOWN */;
+    let spaceObjectType;
     switch (params.bodyType) {
       case "dwarf_planet" /* DWARF_PLANET */:
         spaceObjectType = 36 /* DWARF_PLANET */;
@@ -19289,6 +19539,11 @@ var Thrust = class {
       crosstrack * 1e-3
     );
   }
+  center;
+  radial;
+  intrack;
+  crosstrack;
+  durationRate;
   deltaV;
   get magnitude() {
     return this.deltaV.magnitude() * 1e3;
@@ -19327,6 +19582,9 @@ var Hill = class _Hill {
     this.semimajorAxis_ = semimajorAxis;
     this.meanMotion_ = Earth.smaToMeanMotion(this.semimajorAxis_);
   }
+  epoch;
+  position;
+  velocity;
   semimajorAxis_;
   meanMotion_;
   static fromState(origin, radialPosition, intrackPosition, nodeVelocity, nodeOffsetTime) {
@@ -19503,7 +19761,7 @@ var Hill = class _Hill {
     postManeuvers = postManeuvers.slice();
     let output = preManeuvers;
     output.sort((a, b) => a.center.difference(b.center));
-    output = output.filter((mvr) => mvr.center >= this.epoch && mvr.center >= pivot);
+    output = output.filter((mvr) => mvr.center.posix >= this.epoch.posix && mvr.center.posix >= pivot.posix);
     for (const mvr of output) {
       state = state.maneuver(mvr);
     }
@@ -19613,6 +19871,13 @@ var RadecTopocentric = class _RadecTopocentric {
     this.declinationRate = declinationRate;
     this.rangeRate = rangeRate;
   }
+  epoch;
+  rightAscension;
+  declination;
+  range;
+  rightAscensionRate;
+  declinationRate;
+  rangeRate;
   /**
    * Create a new RadecTopocentric object, using degrees for the angular values.
    * @param epoch UTC epoch.
@@ -19625,8 +19890,8 @@ var RadecTopocentric = class _RadecTopocentric {
    * @returns A new RadecTopocentric object.
    */
   static fromDegrees(epoch, rightAscensionDegrees, declinationDegrees, range, rightAscensionRateDegrees, declinationRateDegrees, rangeRate) {
-    const rightAscensionRate = rightAscensionRateDegrees ? rightAscensionRateDegrees * DEG2RAD : null;
-    const declinationRate = declinationRateDegrees ? declinationRateDegrees * DEG2RAD : null;
+    const rightAscensionRate = typeof rightAscensionRateDegrees === "number" ? rightAscensionRateDegrees * DEG2RAD : null;
+    const declinationRate = typeof declinationRateDegrees === "number" ? declinationRateDegrees * DEG2RAD : null;
     const normalizedRA = ((rightAscensionDegrees * DEG2RAD + Math.PI) % TAU + TAU) % TAU - Math.PI;
     return new _RadecTopocentric(
       epoch,
@@ -19696,14 +19961,14 @@ var RadecTopocentric = class _RadecTopocentric {
    * @returns The right ascension rate in degrees per second, or null if it is not available.
    */
   get rightAscensionRateDegrees() {
-    return this.rightAscensionRate ? this.rightAscensionRate * RAD2DEG : null;
+    return typeof this.rightAscensionRate === "number" ? this.rightAscensionRate * RAD2DEG : null;
   }
   /**
    * Gets the rate of change of declination in degrees per second.
    * @returns The rate of change of declination in degrees per second, or null if the declination rate is not defined.
    */
   get declinationRateDegrees() {
-    return this.declinationRate ? this.declinationRate * RAD2DEG : null;
+    return typeof this.declinationRate === "number" ? this.declinationRate * RAD2DEG : null;
   }
   /**
    * Return the position relative to the observer site.
@@ -19727,7 +19992,7 @@ var RadecTopocentric = class _RadecTopocentric {
    * @returns A Vector3D object.
    */
   velocity(site, range, rangeRate) {
-    if (!this.rightAscensionRate || !this.declinationRate) {
+    if (typeof this.rightAscensionRate !== "number" || typeof this.declinationRate !== "number") {
       throw new Error("Velocity unsolvable, missing ra/dec rates.");
     }
     const r = range ?? this.range ?? 1;
@@ -19782,6 +20047,9 @@ var ObservationOptical = class _ObservationOptical extends Observation {
     this.observation = observation;
     this.noise_ = noise_;
   }
+  site_;
+  observation;
+  noise_;
   // / Inertial site location.
   get site() {
     return this.site_;
@@ -19872,6 +20140,9 @@ var ObservationRadar = class _ObservationRadar extends Observation {
     this.observation = observation;
     this.noise_ = noise_;
   }
+  site_;
+  observation;
+  noise_;
   // / Default noise matrix.
   static defaultNoise = _ObservationRadar.noiseFromSigmas(0.32, 0.015 * DEG2RAD, 0.015 * DEG2RAD);
   get epoch() {
@@ -19952,6 +20223,13 @@ var RadecGeocentric = class _RadecGeocentric {
     this.declinationRate = declinationRate;
     this.rangeRate = rangeRate;
   }
+  epoch;
+  rightAscension;
+  declination;
+  range;
+  rightAscensionRate;
+  declinationRate;
+  rangeRate;
   /**
    * Creates a RadecGeocentric object from the given parameters in degrees.
    * @param epoch - The epoch in UTC.
@@ -19964,8 +20242,8 @@ var RadecGeocentric = class _RadecGeocentric {
    * @returns A new RadecGeocentric object.
    */
   static fromDegrees(epoch, rightAscensionDegrees, declinationDegrees, range, rightAscensionRateDegrees, declinationRateDegrees, rangeRate) {
-    const rightAscensionRate = rightAscensionRateDegrees ? rightAscensionRateDegrees * DEG2RAD : null;
-    const declinationRate = declinationRateDegrees ? declinationRateDegrees * DEG2RAD : null;
+    const rightAscensionRate = typeof rightAscensionRateDegrees === "number" ? rightAscensionRateDegrees * DEG2RAD : null;
+    const declinationRate = typeof declinationRateDegrees === "number" ? declinationRateDegrees * DEG2RAD : null;
     return new _RadecGeocentric(
       epoch,
       rightAscensionDegrees * DEG2RAD,
@@ -20002,7 +20280,7 @@ var RadecGeocentric = class _RadecGeocentric {
     const declinationRate = (vK - rangeRate * (rK / rMag)) / rIJMag;
     return new _RadecGeocentric(
       state.epoch,
-      rightAscension % TAU,
+      (rightAscension % TAU + TAU) % TAU,
       declination,
       rMag,
       rightAscensionRate,
@@ -20015,7 +20293,8 @@ var RadecGeocentric = class _RadecGeocentric {
    * @returns The right ascension in degrees.
    */
   get rightAscensionDegrees() {
-    return this.rightAscension * RAD2DEG;
+    const deg = this.rightAscension * RAD2DEG;
+    return (deg % 360 + 360) % 360;
   }
   /**
    * Gets the declination in degrees.
@@ -20029,14 +20308,14 @@ var RadecGeocentric = class _RadecGeocentric {
    * @returns The right ascension rate in degrees per second, or null if it is not available.
    */
   get rightAscensionRateDegrees() {
-    return this.rightAscensionRate ? this.rightAscensionRate * RAD2DEG : null;
+    return typeof this.rightAscensionRate === "number" ? this.rightAscensionRate * RAD2DEG : null;
   }
   /**
    * Gets the rate of change of declination in degrees per second.
    * @returns The rate of change of declination in degrees per second, or null if not available.
    */
   get declinationRateDegrees() {
-    return this.declinationRate ? this.declinationRate * RAD2DEG : null;
+    return typeof this.declinationRate === "number" ? this.declinationRate * RAD2DEG : null;
   }
   /**
    * Calculates the position vector in geocentric coordinates.
@@ -20056,7 +20335,7 @@ var RadecGeocentric = class _RadecGeocentric {
    * @throws Error if the right ascension rate or declination rate is missing.
    */
   velocity(range, rangeRate) {
-    if (!this.rightAscensionRate || !this.declinationRate) {
+    if (typeof this.rightAscensionRate !== "number" || typeof this.declinationRate !== "number") {
       throw new Error("Velocity unsolvable, missing ra/dec rates.");
     }
     const r = range ?? this.range ?? 1;
@@ -20474,12 +20753,143 @@ var RandomGaussianSource = class {
   }
 };
 
+// src/external/Sgp4WasmTypes.ts
+var Sgp4WasmLogLevel = /* @__PURE__ */ ((Sgp4WasmLogLevel3) => {
+  Sgp4WasmLogLevel3[Sgp4WasmLogLevel3["None"] = 0] = "None";
+  Sgp4WasmLogLevel3[Sgp4WasmLogLevel3["Info"] = 1] = "Info";
+  Sgp4WasmLogLevel3[Sgp4WasmLogLevel3["Warn"] = 2] = "Warn";
+  Sgp4WasmLogLevel3[Sgp4WasmLogLevel3["Error"] = 3] = "Error";
+  return Sgp4WasmLogLevel3;
+})(Sgp4WasmLogLevel || {});
+var Sgp4WasmError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "Sgp4WasmError";
+  }
+  code;
+};
+var SGP4_WASM_DYN_ARR_ERRORS = {
+  [-1]: "Error allocating space for the dynamic array",
+  [-2]: "Dynamic array is already initialized",
+  [-3]: "The requested size is too large",
+  [-4]: "The requested size is negative"
+};
+var SGP4_WASM_ADD_SAT_ERRORS = {
+  [-1]: "Dynamic array has not been allocated",
+  [-2]: "Dynamic array is out of space (call reallocDynArr)",
+  [-3]: "Failed to determine satKey from line 1",
+  [-4]: "Failed to parse line 1 or line 2"
+};
+
+// src/propagator/Sgp4WasmPropagator.ts
+var Sgp4WasmPropagator = class extends Propagator {
+  constructor(wasm_, tle_) {
+    super();
+    this.wasm_ = wasm_;
+    this.tle_ = tle_;
+    if (!wasm_.isLoaded) {
+      throw new Sgp4WasmError("Sgp4WasmPropagator requires a loaded Sgp4Wasm instance. Call load() first.");
+    }
+    this.satKey_ = wasm_.addSat(tle_.line1, tle_.line2);
+    wasm_.initSats([this.satKey_]);
+    this.cacheState_ = this.propagate(tle_.epoch);
+  }
+  wasm_;
+  tle_;
+  satKey_;
+  cacheState_;
+  checkpoints_ = [];
+  /**
+   * The Astro Standards satKey backing this propagator.
+   */
+  get satKey() {
+    return this.satKey_;
+  }
+  /**
+   * Gets the state of the propagator in the J2000 coordinate system.
+   * @returns The J2000 state of the propagator.
+   */
+  get state() {
+    return this.cacheState_;
+  }
+  /**
+   * 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, _finish, _maneuvers, _interval = 60) {
+    throw new Error("Maneuvers cannot be modelled with SGP4.");
+  }
+  /**
+   * 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, _interval = 60) {
+    throw new Error("Maneuvers cannot be modelled with SGP4.");
+  }
+  /**
+   * 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) {
+    const state = this.wasm_.propagateEpoch(this.satKey_, epoch);
+    if (state.err !== 0) {
+      throw new Sgp4WasmError(`SGP4 propagation failed for satKey ${this.satKey_} (code ${state.err})`, state.err);
+    }
+    this.cacheState_ = new TEME(epoch, state.position, state.velocity).toJ2000();
+    return this.cacheState_;
+  }
+  /**
+   * Resets the state of the propagator to the TLE epoch state.
+   */
+  reset() {
+    this.cacheState_ = this.propagate(this.tle_.epoch);
+  }
+  /**
+   * Saves the current state of the propagator and returns the index of the checkpoint.
+   * @returns The index of the checkpoint.
+   */
+  checkpoint() {
+    this.checkpoints_.push(this.cacheState_);
+    return this.checkpoints_.length - 1;
+  }
+  /**
+   * Clears all the checkpoints in the propagator.
+   */
+  clearCheckpoints() {
+    this.checkpoints_ = [];
+  }
+  /**
+   * Restores the state of the propagator to a previously saved checkpoint.
+   * @param index - The index of the checkpoint to restore.
+   */
+  restore(index) {
+    this.cacheState_ = this.checkpoints_[index];
+  }
+  /**
+   * Removes the satellite from the backing wasm instance's SGP4 and TLE
+   * registries.
+   */
+  dispose() {
+    this.wasm_.uninitSats([this.satKey_]);
+    this.wasm_.removeSats([this.satKey_]);
+  }
+};
+
 // src/observation/PropagatorPairs.ts
 var PropagatorPairs = class {
   constructor(posStep_, velStep_) {
     this.posStep_ = posStep_;
     this.velStep_ = velStep_;
   }
+  posStep_;
+  velStep_;
   _high = Array(6).fill(null);
   _low = Array(6).fill(null);
   set(index, high, low) {
@@ -20513,6 +20923,9 @@ var BatchLeastSquaresResult = class {
     this.covariance = covariance2;
     this.rms = rms;
   }
+  state;
+  covariance;
+  rms;
 };
 
 // src/orbit-determination/BatchLeastSquaresOD.ts
@@ -20543,6 +20956,12 @@ var BatchLeastSquaresOD = class _BatchLeastSquaresOD {
     this.propagator_ = new RungeKutta89Propagator(this.apriori_, this.forceModel_);
     this.nominal_ = this.propagator_.propagate(this.start_);
   }
+  observations_;
+  apriori_;
+  forceModel_;
+  posStep_;
+  velStep_;
+  fastDerivatives_;
   /** Propagator pair cache, for generating observation Jacobians. */
   propPairs_;
   /**  Nominal state propagator. */
@@ -20643,6 +21062,7 @@ var GibbsIOD = class _GibbsIOD {
   constructor(mu = Earth.mu) {
     this.mu = mu;
   }
+  mu;
   /** Abort solve if position plane exceeds this value. */
   static coplanarThreshold_ = 5 * DEG2RAD;
   /**
@@ -20701,6 +21121,7 @@ var HerrickGibbsIOD = class {
   constructor(mu = Earth.mu) {
     this.mu = mu;
   }
+  mu;
   // / Attempt to create a state estimate from three inertial position vectors.
   solve(r1, t1, r2, t2, r3, t3) {
     const dt31 = t3.difference(t1);
@@ -20961,6 +21382,7 @@ var LambertIOD = class _LambertIOD {
   constructor(mu = Earth.mu) {
     this.mu = mu;
   }
+  mu;
   /**
    * Try to guess the short path argument given an [interceptor] and
    * [target] state.
@@ -21216,10 +21638,9 @@ var GoodingIOD = class _GoodingIOD {
    * @returns Orbit estimate referenced to the epoch of the second observation
    */
   estimate(o1, o2, o3, rho1init = null, rho3init = null, nRev = 0, direction = true) {
-    let orbit = null;
     if (rho1init === null || rho3init === null) {
       const gaussIod = new GaussIOD(this._mu);
-      orbit = gaussIod.estimate(o1, o2, o3);
+      const orbit = gaussIod.estimate(o1, o2, o3);
       if (orbit === null) {
         throw new OrbitDeterminationError("Gauss IOD failed to provide initial estimate for Gooding IOD", "Gooding");
       }
@@ -21648,6 +22069,11 @@ var LevenbergMarquardtResult = class {
     this.iterations = iterations;
     this.converged = converged;
   }
+  state;
+  covariance;
+  rms;
+  iterations;
+  converged;
 };
 
 // src/orbit-determination/LevenbergMarquardtOD.ts
@@ -21678,6 +22104,12 @@ var LevenbergMarquardtOD = class _LevenbergMarquardtOD {
     const propagator = new RungeKutta89Propagator(this.apriori_, this.forceModel_);
     this.nominal_ = propagator.propagate(this.start_);
   }
+  observations_;
+  apriori_;
+  forceModel_;
+  posStep_;
+  velStep_;
+  fastDerivatives_;
   /** Propagator pair cache, for generating observation Jacobians. */
   propPairs_;
   /**  State estimate during solve. */
@@ -21836,6 +22268,8 @@ var SimplexEntry = class _SimplexEntry {
     this.x_ = new Vector(points);
     this.score = this.f_(points);
   }
+  f_;
+  points;
   /**
    * The cost function score at this vertex.
    *
@@ -22114,6 +22548,18 @@ var ModifiedGoodingIOD = class {
     };
     return scoreFn;
   }
+  /**
+   * 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, r0, rN, {
     nRev = 0,
     direction = true,
@@ -22577,6 +23023,8 @@ var ConjunctionAssessment = class {
     this.primaryProp = this.createPropagator(primary, false);
     this.secondaryProp = this.createPropagator(secondary, false);
   }
+  primary;
+  secondary;
   primaryProp;
   secondaryProp;
   primaryCovSample;
@@ -23811,7 +24259,7 @@ var PhasedArrayRadar = class _PhasedArrayRadar extends RadarSensor {
     this.validateFace_(face);
     const azRad = az * DEG2RAD;
     const elRad = el * DEG2RAD;
-    const azDiff = azRad - this.boresightAzRad(face);
+    const azDiff = wrapAngle(azRad - this.boresightAzRad(face));
     const elDiff = elRad - this.boresightElRad(face);
     return azel2uv(azDiff, elDiff, this.beamwidthRad);
   }
@@ -23905,9 +24353,7 @@ var PhasedArrayRadar = class _PhasedArrayRadar extends RadarSensor {
   getVisibleFaces(az, el, maxAngle = 60) {
     const visibleFaces = [];
     for (let face = 0; face < this.faceCount; face++) {
-      const azDiff = Math.abs(az - this.boresightAz[face]);
-      const elDiff = Math.abs(el - this.boresightEl[face]);
-      const angularDist = Math.sqrt(azDiff * azDiff + elDiff * elDiff);
+      const angularDist = this.angleFromBoresight_(az, el, face);
       if (angularDist <= maxAngle) {
         visibleFaces.push(face);
       }
@@ -23924,9 +24370,7 @@ var PhasedArrayRadar = class _PhasedArrayRadar extends RadarSensor {
     let bestFace = -1;
     let minDist = Infinity;
     for (let face = 0; face < this.faceCount; face++) {
-      const azDiff = az - this.boresightAz[face];
-      const elDiff = el - this.boresightEl[face];
-      const dist = Math.sqrt(azDiff * azDiff + elDiff * elDiff);
+      const dist = this.angleFromBoresight_(az, el, face);
       if (dist < minDist && dist < 90) {
         minDist = dist;
         bestFace = face;
@@ -23934,6 +24378,24 @@ var PhasedArrayRadar = class _PhasedArrayRadar extends RadarSensor {
     }
     return bestFace;
   }
+  /**
+   * 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
+   */
+  angleFromBoresight_(az, el, face) {
+    return angularDistance(
+      az * DEG2RAD,
+      el * DEG2RAD,
+      this.boresightAz[face] * DEG2RAD,
+      this.boresightEl[face] * DEG2RAD,
+      1 /* Haversine */
+    ) * RAD2DEG;
+  }
   // ==================== Serialization ====================
   serializeSpecific() {
     return {
@@ -24444,20 +24906,97 @@ var PassiveRFSensor = class _PassiveRFSensor extends Sensor {
   }
 };
 
-// src/parsers/HorizonsParser.ts
-function julianDateToDate(jd) {
-  const unixMs = (jd - 24405875e-1) * 864e5;
-  return new Date(unixMs);
-}
-var HorizonsParser = class {
-  constructor() {
+// src/sensor/TtcAntenna.ts
+var TtcAntenna = class _TtcAntenna extends Sensor {
+  /** Antenna dish diameter in meters */
+  antennaDiameter;
+  /** Antenna gain in dB */
+  antennaGain;
+  /** Whether the station supports two-way ranging */
+  hasRanging;
+  /** Whether the station can uplink commands */
+  hasUplink;
+  constructor(params) {
+    const paramsWithType = {
+      ...params,
+      sensorType: "TT_C_ANTENNA" /* TT_C_ANTENNA */
+    };
+    super(paramsWithType);
+    this.antennaDiameter = params.antennaDiameter;
+    this.antennaGain = params.antennaGain;
+    this.hasRanging = params.hasRanging ?? true;
+    this.hasUplink = params.hasUplink ?? true;
   }
   /**
-   * Parses NASA Horizons vector table format.
-   *
-   * Expects output from Horizons with settings:
-   * - VECTORS (type 2 or 3)
-   * - Output in km and km/s
+   * 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, date = /* @__PURE__ */ new Date()) {
+    if (!this.canObserve(target, date)) {
+      return null;
+    }
+    const sensorJ2000 = this.getJ2000(date);
+    const targetJ2000 = target.toJ2000(date);
+    const radec = RadecTopocentric.fromStateVector(targetJ2000, sensorJ2000);
+    return new ObservationOptical(sensorJ2000, radec);
+  }
+  serializeSpecific() {
+    return {
+      antennaDiameter: this.antennaDiameter,
+      antennaGain: this.antennaGain,
+      hasRanging: this.hasRanging,
+      hasUplink: this.hasUplink
+    };
+  }
+  /**
+   * 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() {
+    return new _TtcAntenna({
+      id: this.id,
+      name: this.name,
+      sensorType: this.sensorType,
+      fieldOfView: this.fieldOfView.serialize(),
+      antennaDiameter: this.antennaDiameter,
+      antennaGain: this.antennaGain,
+      hasRanging: this.hasRanging,
+      hasUplink: this.hasUplink,
+      shortName: this.shortName,
+      system: this.system,
+      country: this.country,
+      operator: this.operator,
+      dwellTime: this.dwellTime,
+      freqBand: this.freqBand,
+      isVolumetric: this.isVolumetric,
+      url: this.url,
+      metadata: this.metadata ? { ...this.metadata } : void 0
+    });
+  }
+};
+
+// src/parsers/HorizonsParser.ts
+function julianDateToDate(jd) {
+  const unixMs = (jd - 24405875e-1) * 864e5;
+  return new Date(unixMs);
+}
+function tdbDateToEpochUtc(tdb) {
+  const j2000Posix = 946728e3;
+  return EpochUTC.fromJ2000TTSeconds(tdb.getTime() / 1e3 - j2000Posix);
+}
+var HorizonsParser = class {
+  constructor() {
+  }
+  /**
+   * Parses NASA Horizons vector table format.
+   *
+   * Expects output from Horizons with settings:
+   * - VECTORS (type 2 or 3)
+   * - Output in km and km/s
    *
    * @param data - Raw Horizons output text
    * @returns Parsed ephemeris data
@@ -24480,22 +25019,34 @@ var HorizonsParser = class {
     let referenceFrame = "";
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i].trim();
-      if (line.startsWith("Target body name:")) {
-        targetName = this.extractTargetName_(line, "Target body name:");
-        metadata.targetName = targetName;
-      } else if (line.startsWith("Center body name:")) {
-        centerBody = this.extractValue_(line, "Center body name:");
-        metadata.centerBody = centerBody;
-      } else if (line.startsWith("Center-site name:") && !centerBody) {
-        centerBody = this.extractValue_(line, "Center-site name:");
-        metadata.centerBody = centerBody;
-      } else if (line.startsWith("Output type:")) {
-        metadata.outputType = this.extractValue_(line, "Output type:");
-      } else if (line.startsWith("Reference frame:")) {
-        referenceFrame = this.extractValue_(line, "Reference frame:");
-        metadata.referenceFrame = referenceFrame;
-      } else if (line.startsWith("Output units:")) {
-        metadata.outputUnits = this.extractValue_(line, "Output units:");
+      const meta = this.matchMetadataLine_(line);
+      if (meta) {
+        switch (meta.label) {
+          case "Target body name":
+            targetName = this.stripNameSuffixes_(meta.value);
+            metadata.targetName = targetName;
+            break;
+          case "Center body name":
+            centerBody = meta.value;
+            metadata.centerBody = centerBody;
+            break;
+          case "Center-site name":
+            if (!centerBody) {
+              centerBody = meta.value;
+              metadata.centerBody = centerBody;
+            }
+            break;
+          case "Output type":
+            metadata.outputType = meta.value;
+            break;
+          case "Reference frame":
+            referenceFrame = meta.value;
+            metadata.referenceFrame = referenceFrame;
+            break;
+          case "Output units":
+            metadata.outputUnits = meta.value;
+            break;
+        }
       }
       if (line === "$$SOE") {
         inData = true;
@@ -24540,10 +25091,12 @@ var HorizonsParser = class {
     let observerLocation = "";
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i].trim();
-      if (line.startsWith("Target body name:")) {
-        targetName = this.extractTargetName_(line, "Target body name:");
-      } else if (line.startsWith("Center-site name:")) {
-        observerLocation = this.extractValue_(line, "Center-site name:");
+      const targetRaw = this.extractLabeledValue_(line, "Target body name");
+      const siteRaw = this.extractLabeledValue_(line, "Center-site name");
+      if (targetRaw !== null) {
+        targetName = this.stripNameSuffixes_(targetRaw);
+      } else if (siteRaw !== null) {
+        observerLocation = siteRaw;
       }
       if (line === "$$SOE") {
         inData = true;
@@ -24567,23 +25120,51 @@ var HorizonsParser = class {
     };
   }
   // ==================== Private Helper Methods ====================
+  /** Metadata labels recognized in Horizons output headers. */
+  static metadataLabels_ = [
+    "Target body name",
+    "Center body name",
+    "Center-site name",
+    "Output type",
+    "Reference frame",
+    "Output units"
+  ];
   /**
-   * 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.
    */
-  static extractValue_(line, key) {
-    const value = line.substring(key.length).trim();
-    return value.split(/\s{2,}/u)[0].trim();
+  static extractLabeledValue_(line, label) {
+    if (!line.startsWith(label)) {
+      return null;
+    }
+    const rest = line.substring(label.length);
+    const colonIdx = rest.indexOf(":");
+    if (colonIdx === -1 || rest.substring(0, colonIdx).trim().length > 0) {
+      return null;
+    }
+    return rest.substring(colonIdx + 1).trim().split(/\s{2,}/u)[0].trim();
+  }
+  /** Returns the first recognized metadata label/value on the line, if any. */
+  static matchMetadataLine_(line) {
+    for (const label of this.metadataLabels_) {
+      const value = this.extractLabeledValue_(line, label);
+      if (value !== null) {
+        return { label, value };
+      }
+    }
+    return null;
   }
   /**
-   * 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"
    */
-  static extractTargetName_(line, key) {
-    const raw = this.extractValue_(line, key);
+  static stripNameSuffixes_(raw) {
     const parenIdx = raw.search(/\s\(/u);
     if (parenIdx > 0) {
       return raw.substring(0, parenIdx).trim();
@@ -24604,7 +25185,7 @@ var HorizonsParser = class {
           if (isNaN(jd)) {
             return null;
           }
-          const epoch2 = EpochUTC.fromDateTime(julianDateToDate(jd));
+          const epoch2 = tdbDateToEpochUtc(julianDateToDate(jd));
           const x2 = parseFloat(parts[1]);
           const y2 = parseFloat(parts[2]);
           const z2 = parseFloat(parts[3]);
@@ -24652,7 +25233,8 @@ var HorizonsParser = class {
     };
     const month = monthMap[monthStr] ?? 0;
     const date = new Date(Date.UTC(year, month, day, hour, minute, Math.floor(second), second % 1 * 1e3));
-    const epoch = EpochUTC.fromDateTime(date);
+    const isUt = /\bUTC?\b/u.test(line.slice(dateMatch[0].length));
+    const epoch = isUt ? EpochUTC.fromDateTime(date) : tdbDateToEpochUtc(date);
     let nextIndex = currentIndex + 1;
     if (nextIndex >= allLines.length) {
       return null;
@@ -26570,7 +27152,7 @@ var Transmitter = class _Transmitter extends CommunicationDevice {
     const distance = this.getDistanceTo(receiver, date);
     const fspl = calculateFspl(distance, this.frequency);
     const receivedPower = this.eirp - fspl + receiver.antenna.gain - receiver.lineLoss;
-    const noiseFloorDbw = -204 + 10 * Math.log10(this.bandwidth) + receiver.noiseFigure;
+    const noiseFloorDbw = receiver.noiseFloor;
     const snr = receivedPower - noiseFloorDbw;
     return {
       eirp: this.eirp,
@@ -27310,6 +27892,11 @@ var ChebyshevCoefficients = class _ChebyshevCoefficients {
     this.cyd_ = _ChebyshevCoefficients._derivative(a, b, cy_);
     this.czd_ = _ChebyshevCoefficients._derivative(a, b, cz_);
   }
+  a;
+  b;
+  cx_;
+  cy_;
+  cz_;
   cxd_;
   cyd_;
   czd_;
@@ -27641,6 +28228,43 @@ var PlaneChangeBurn = class _PlaneChangeBurn {
   }
 };
 
+// src/maneuver/PropellantBudget.ts
+var PropellantBudget = class _PropellantBudget {
+  /** Standard gravity used by the specific-impulse definition (m/s^2). */
+  static 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, deltaVMs, ispS) {
+    return massKg * Math.exp(-deltaVMs / (ispS * _PropellantBudget.g0));
+  }
+  /**
+   * 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, deltaVMs, ispS) {
+    return massKg - _PropellantBudget.massAfterBurn(massKg, deltaVMs, ispS);
+  }
+  /**
+   * 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, dryMassKg, ispS) {
+    return ispS * _PropellantBudget.g0 * Math.log(massKg / dryMassKg);
+  }
+};
+
 // src/maneuver/Waypoint.ts
 var Waypoint = class _Waypoint {
   epoch;
@@ -27829,6 +28453,11 @@ var TwoBurnOrbitTransfer = class _TwoBurnOrbitTransfer {
     this.vTransB = vTransB;
     this.tTrans = tTrans;
   }
+  vInit;
+  vFinal;
+  vTransA;
+  vTransB;
+  tTrans;
   /**
    * Calculates the parameters for a Hohmann transfer orbit between two circular orbits.
    * @param rInit The initial radius of the orbit. (km)
@@ -27843,6 +28472,55 @@ var TwoBurnOrbitTransfer = class _TwoBurnOrbitTransfer {
     const tTrans = Math.PI * Math.sqrt((rInit + rFinal) ** 3 / (8 * Earth.mu));
     return new _TwoBurnOrbitTransfer(vInit, vFinal, vTransA, vTransB, tTrans);
   }
+  /**
+   * 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, rFinal, deltaIncRad) {
+    const vInit = Math.sqrt(Earth.mu / rInit);
+    const vFinal = Math.sqrt(Earth.mu / rFinal);
+    const vTransInit = Math.sqrt(Earth.mu * (2 / rInit - 2 / (rInit + rFinal)));
+    const vTransFinal = Math.sqrt(Earth.mu * (2 / rFinal - 2 / (rInit + rFinal)));
+    const tTrans = Math.PI * Math.sqrt((rInit + rFinal) ** 3 / (8 * Earth.mu));
+    const combined = (v1, v2) => Math.sqrt(v1 ** 2 + v2 ** 2 - 2 * v1 * v2 * Math.cos(deltaIncRad));
+    let planeChangeBurn;
+    let deltaV1;
+    let deltaV2;
+    if (deltaIncRad === 0) {
+      planeChangeBurn = "none";
+      deltaV1 = Math.abs(vTransInit - vInit);
+      deltaV2 = Math.abs(vFinal - vTransFinal);
+    } else if (rFinal >= rInit) {
+      planeChangeBurn = "burn2";
+      deltaV1 = Math.abs(vTransInit - vInit);
+      deltaV2 = combined(vTransFinal, vFinal);
+    } else {
+      planeChangeBurn = "burn1";
+      deltaV1 = combined(vInit, vTransInit);
+      deltaV2 = Math.abs(vFinal - vTransFinal);
+    }
+    return {
+      vInit,
+      vFinal,
+      deltaV1,
+      deltaV2,
+      deltaVTotal: deltaV1 + deltaV2,
+      tTrans,
+      planeChangeBurn
+    };
+  }
   // / Return the total delta-velocity magnitude for both maneuvers _(km/s)_.
   get deltaV() {
     return Math.abs(this.vTransA) + Math.abs(this.vTransB);
@@ -27881,6 +28559,7 @@ var ChebyshevCompressor = class _ChebyshevCompressor {
   constructor(interpolator_) {
     this.interpolator_ = interpolator_;
   }
+  interpolator_;
   /** Returns the cosine of π times x. */
   static cosPi_(x) {
     return Math.cos(Math.PI * x);
@@ -28121,6 +28800,8 @@ var SimpleLinearRegression = class _SimpleLinearRegression {
     this.ys = ys;
     this.update();
   }
+  xs;
+  ys;
   /** Line slope (m in y = mx + b). */
   slope_ = 0;
   /** Y-axis intercept (b in y = mx + b). */
@@ -29319,8 +30000,7 @@ var LaunchTrajectoryGenerator = class _LaunchTrajectoryGenerator {
         azimuthRad,
         dr
       );
-      const gmst = epoch.gmstAngle();
-      const pos = _LaunchTrajectoryGenerator.geodeticToEci_(lat, lon, alt, gmst);
+      const pos = _LaunchTrajectoryGenerator.geodeticToJ2000_(lat, lon, alt, epoch);
       positions.push({ epoch, pos });
     }
     for (let i = 0; i < positions.length; i++) {
@@ -29418,20 +30098,17 @@ var LaunchTrajectoryGenerator = class _LaunchTrajectoryGenerator {
     return { lat, lon };
   }
   /**
-   * 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.)
    */
-  static geodeticToEci_(latRad, lonRad, altKm, gmst) {
-    const cosLat = Math.cos(latRad);
-    const sinLat = Math.sin(latRad);
-    const cosLon = Math.cos(lonRad + gmst);
-    const sinLon = Math.sin(lonRad + gmst);
-    const r = Earth.radiusMean + altKm;
-    return new Vector3D(
-      r * cosLat * cosLon,
-      r * cosLat * sinLon,
-      r * sinLat
-    );
+  static geodeticToJ2000_(latRad, lonRad, altKm, epoch) {
+    const lonWrapped = Math.atan2(Math.sin(lonRad), Math.cos(lonRad));
+    return new Geodetic(latRad, lonWrapped, altKm).toITRF(epoch).toJ2000().position;
   }
   /**
    * Compute the orbital velocity vector at the insertion point.
@@ -29552,390 +30229,175 @@ var LaunchTrajectoryGenerator = class _LaunchTrajectoryGenerator {
   }
 };
 
-// src/orbit-design/OrbitFinder.ts
-var OrbitFinder = class _OrbitFinder {
-  static MAX_LAT_ERROR = 0.025;
-  static MAX_LON_ERROR = 0.025;
-  static MAX_ALT_ERROR = 10;
-  static MAX_ITERATIONS = 5e3;
-  static COARSE_STEP = 1;
-  // degrees
-  static FINE_STEP = 5e-3;
-  // degrees
-  sat_;
-  goalParams_;
-  now_;
-  goalDirection_;
-  debugCallback_;
-  currentParams_;
-  lastLatitude_ = null;
-  currentDirection_ = null;
-  constructor(sat, goalLat, goalLon, goalDirection, now, goalAlt, raanOffset = 0, options) {
-    this.sat_ = sat;
-    this.now_ = now;
-    this.goalDirection_ = goalDirection;
-    this.debugCallback_ = options?.debugCallback;
-    this.goalParams_ = {
-      meanAnomaly: 0,
-      argOfPerigee: sat.argOfPerigee,
-      raan: sat.rightAscension + raanOffset,
-      altitude: goalAlt || 0,
-      latitude: goalLat,
-      longitude: goalLon
+// src/orbit-design/LaunchWindow.ts
+var LaunchWindowFinder = class _LaunchWindowFinder {
+  options_;
+  constructor(options) {
+    this.options_ = {
+      searchHours: 24,
+      coarseStepSec: 60,
+      fineStepSec: 1,
+      ...options
     };
-    this.currentParams_ = this.getCurrentOrbitParams_();
   }
   /**
-   * 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.
+   * 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).
    */
-  rotateOrbitToLatLon() {
-    try {
-      if (this.goalParams_.altitude > 0) {
-        const perigeeParams = this.findPerigeePosition_();
-        this.debug_(`Original perigee position: ${perigeeParams.latitude} - ${perigeeParams.longitude} - ${perigeeParams.altitude}`);
-        this.updateOrbitWithoutDirectionCheck_({
-          meanAnomaly: 0
-        });
-        this.debug_(`Positioned at initial perigee: ${this.currentParams_.latitude} - ${this.currentParams_.longitude} - ${this.currentParams_.altitude}`);
-        let bestArgPerigee = this.currentParams_.argOfPerigee;
-        let bestLatError = Infinity;
-        for (let argPer = 0; argPer < 360; argPer += 0.25) {
-          this.updateOrbitWithoutDirectionCheck_({
-            meanAnomaly: 0,
-            argOfPerigee: argPer
-          });
-          const latError = Math.abs(this.currentParams_.latitude - perigeeParams.latitude);
-          if (latError < bestLatError) {
-            bestLatError = latError;
-            bestArgPerigee = argPer;
-            this.debug_(`New best arg perigee: ${argPer} with lat error ${latError}`);
-          }
-          if (latError <= _OrbitFinder.MAX_LAT_ERROR) {
-            break;
-          }
-        }
-        this.updateOrbitWithoutDirectionCheck_({
-          meanAnomaly: 0,
-          argOfPerigee: bestArgPerigee
-        });
-        this.debug_(`After arg perigee adjustment: ${this.currentParams_.latitude} - ${this.currentParams_.longitude} - ${this.currentParams_.altitude}`);
-        this.lastLatitude_ = null;
-        this.currentDirection_ = null;
-        const finalMeanAResult = this.meanACalcLoop_(this.goalDirection_);
-        if (finalMeanAResult !== 1 /* Success */) {
-          return ["Error", "Failed to find final target position"];
-        }
-        const successfulDirection = this.currentDirection_;
-        const newRaan = this.linearSearchRaan_();
-        this.currentDirection_ = successfulDirection;
-        const finalSuccess = this.updateOrbit_({
-          meanAnomaly: this.currentParams_.meanAnomaly,
-          raan: newRaan,
-          argOfPerigee: bestArgPerigee
-        });
-        if (!finalSuccess) {
-          return ["Error", "Final position adjustment failed"];
-        }
-        this.debug_(`Final position: ${this.currentParams_.latitude}, ${this.currentParams_.longitude}, ${this.currentParams_.altitude}`);
-        this.debug_(`Target altitude: ${this.goalParams_.altitude}, Current altitude: ${this.currentParams_.altitude}`);
-      } else {
-        const result = this.meanACalcLoop_(this.goalDirection_);
-        if (result !== 1 /* Success */) {
-          return ["Error", `Failed to find solution with ${this.goalDirection_} bound direction`];
-        }
-        const meanAnomalySuccess = this.updateOrbit_({
-          meanAnomaly: this.currentParams_.meanAnomaly
-        });
-        if (!meanAnomalySuccess) {
-          return ["Error", "Mean anomaly adjustment resulted in incorrect direction"];
-        }
-        const successfulDirection = this.currentDirection_;
-        const newRaan = this.linearSearchRaan_();
-        this.currentDirection_ = successfulDirection;
-        const combinedSuccess = this.updateOrbit_({
-          meanAnomaly: this.currentParams_.meanAnomaly,
-          raan: newRaan
-        });
-        if (!combinedSuccess) {
-          return ["Error", "Combined mean anomaly and RAAN adjustment failed"];
-        }
-      }
-      return [
-        this.generateTle1_(),
-        this.generateTle2_(this.currentParams_)
-      ];
-    } catch (error) {
-      this.debug_(`Error in rotateOrbitToLatLon: ${error.message}`);
-      return ["Error", error.message];
-    }
-  }
-  debug_(message) {
-    if (this.debugCallback_) {
-      this.debugCallback_(message);
+  isGeometryPossible() {
+    const sinInc = Math.sin(this.options_.inclination * DEG2RAD);
+    if (sinInc === 0) {
+      return this.options_.siteLat === 0;
     }
+    return Math.abs(Math.sin(this.options_.siteLat * DEG2RAD) / sinInc) <= 1;
   }
-  calculateTimeVariables_(date, satrec) {
-    const j = jday(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()) + date.getUTCMilliseconds() * MILLISECONDS_TO_DAYS;
-    const gmst = Sgp4.gstime(j);
-    const m = satrec ? (j - satrec.jdsatepoch) * MINUTES_PER_DAY : null;
-    return { gmst, m, j };
-  }
-  getCurrentOrbitParams_() {
-    if (!this.sat_?.satrec) {
-      throw new Error("Satellite data is not available");
-    }
-    const { m, gmst } = this.calculateTimeVariables_(this.now_, this.sat_.satrec);
-    if (m === null) {
-      throw new Error("Invalid time variables");
-    }
-    const positionEci = Sgp4.propagate(this.sat_.satrec, m).position;
-    const { lat, lon, alt } = eci2lla(positionEci, gmst);
-    return {
-      meanAnomaly: this.sat_.meanAnomaly,
-      argOfPerigee: this.sat_.argOfPerigee,
-      raan: this.sat_.rightAscension,
-      altitude: alt,
-      latitude: lat,
-      longitude: lon
-    };
+  /**
+   * 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) {
+    const inc = this.options_.inclination * DEG2RAD;
+    const lat = this.options_.siteLat * DEG2RAD;
+    const sinU = Math.sin(lat) / Math.sin(inc);
+    const u = this.options_.direction === "N" ? Math.asin(sinU) : Math.PI - Math.asin(sinU);
+    const nodeToSite = Math.atan2(Math.sin(u) * Math.cos(inc), Math.cos(u));
+    const gmst = Sgp4.gstime(_LaunchWindowFinder.julianDate_(time));
+    const lst = gmst + this.options_.siteLon * DEG2RAD;
+    return _LaunchWindowFinder.normalizeDeg_((lst - nodeToSite) * RAD2DEG);
   }
-  determineDirection_(newLat) {
-    if (this.lastLatitude_ === null) {
-      this.debug_(`Initial latitude: ${newLat}`);
-      this.lastLatitude_ = newLat;
+  /**
+   * 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() {
+    if (!this.isGeometryPossible()) {
       return null;
     }
-    if (this.currentDirection_ && Math.abs(newLat - this.lastLatitude_) < 0.01) {
-      return this.currentDirection_;
-    }
-    const direction = newLat > this.lastLatitude_ ? "N" : "S";
-    this.debug_(`Current latitude: ${this.lastLatitude_} - New latitude: ${newLat} - Direction: ${direction}`);
-    this.lastLatitude_ = newLat;
-    this.debug_(`New direction: ${direction}`);
-    return direction;
-  }
-  isCorrectDirection_() {
-    this.debug_(`Current direction: ${this.currentDirection_} - Goal direction: ${this.goalDirection_}`);
-    return this.currentDirection_ === this.goalDirection_;
-  }
-  updateOrbit_(newParams) {
-    const tle1 = this.generateTle1_();
-    const tle2 = this.generateTle2_(newParams);
-    const satrec = Sgp4.createSatrec(tle1, tle2);
-    if (!satrec) {
-      throw new Error("Invalid orbit parameters");
-    }
-    const { m, gmst } = this.calculateTimeVariables_(this.now_, satrec);
-    if (m === null) {
-      throw new Error("Invalid time variables");
-    }
-    const positionEci = Sgp4.propagate(satrec, m).position;
-    const { lat, lon, alt } = eci2lla(positionEci, gmst);
-    const newDirection = this.determineDirection_(lat);
-    if (newDirection !== null) {
-      this.currentDirection_ = newDirection;
-    }
-    this.currentParams_ = {
-      ...this.currentParams_,
-      ...newParams,
-      latitude: lat,
-      longitude: lon,
-      altitude: alt
-    };
-    return this.isCorrectDirection_();
-  }
-  meanACalcLoop_(direction) {
-    const startVal = direction === "N" ? 0 : 180;
-    const endVal = direction === "N" ? 360 : 540;
-    for (let posVal = startVal * 10; posVal < endVal * 10; posVal += 0.25) {
-      const normalizedVal = posVal % (360 * 10);
-      const result = this.meanACalc_(normalizedVal, this.now_);
-      if (result === 1 /* Success */) {
-        if (this.currentDirection_ !== direction) {
-          posVal += 20;
-        } else {
-          return 1 /* Success */;
-        }
-      }
-      if (result === 3 /* Far */) {
-        posVal += 100;
-      }
-      if (result === 2 /* Error */) {
-        return 2 /* Error */;
-      }
-    }
-    return 0 /* Near */;
-  }
-  meanACalc_(meana, now) {
-    meana /= 10;
-    meana %= 360;
-    const tle1 = this.generateTle1_();
-    const tle2 = this.generateTle2_({ meanAnomaly: meana });
-    const satrec = Sgp4.createSatrec(tle1, tle2);
-    if (!satrec) {
-      return 2 /* Error */;
-    }
-    const { m, gmst } = this.calculateTimeVariables_(now, satrec);
-    if (m === null) {
-      return 2 /* Error */;
-    }
-    const positionEci = Sgp4.propagate(satrec, m).position;
-    const { lat } = eci2lla(positionEci, gmst);
-    if (this.lastLatitude_ !== null) {
-      if (Math.abs(lat - this.lastLatitude_) > 1e-3) {
-        this.currentDirection_ = lat > this.lastLatitude_ ? "N" : "S";
-      }
-    }
-    this.lastLatitude_ = lat;
-    if (Math.abs(lat - this.goalParams_.latitude) <= _OrbitFinder.MAX_LAT_ERROR) {
-      if (this.currentDirection_ === this.goalDirection_) {
-        this.currentParams_.meanAnomaly = meana;
-        return 1 /* Success */;
-      }
-    }
-    if (Math.abs(lat - this.goalParams_.latitude) > 11) {
-      return 3 /* Far */;
-    }
-    return 0 /* Near */;
-  }
-  linearSearchRaan_() {
-    let bestValue = this.currentParams_.raan;
+    const startMs = this.options_.startTime.getTime();
+    const endMs = startMs + this.options_.searchHours * 3600 * 1e3;
+    const coarseMs = this.options_.coarseStepSec * 1e3;
+    let bestMs = startMs;
     let bestError = Infinity;
-    for (let raan = 0; raan < 360; raan += _OrbitFinder.COARSE_STEP) {
-      this.updateOrbit_({ raan });
-      const error = Math.abs(this.calculateError_("raan"));
-      if (error < Math.abs(bestError)) {
+    for (let ms = startMs; ms <= endMs; ms += coarseMs) {
+      const error = Math.abs(this.raanErrorAt_(new Date(ms)));
+      if (error < bestError) {
         bestError = error;
-        bestValue = raan;
-      }
-      if (error < _OrbitFinder.MAX_LON_ERROR) {
-        for (let fineRaan = bestValue - 5; fineRaan <= bestValue + 5; fineRaan += _OrbitFinder.FINE_STEP) {
-          const normalizedRaan = (fineRaan % 360 + 360) % 360;
-          this.updateOrbit_({ raan: normalizedRaan });
-          const fineError = Math.abs(this.calculateError_("raan"));
-          if (fineError < error) {
-            bestValue = normalizedRaan;
-            bestError = fineError;
-          }
-        }
-        return bestValue;
+        bestMs = ms;
       }
     }
-    return bestValue;
-  }
-  normalizeAngleDifference_(angle1, angle2) {
-    const diff = (angle1 - angle2) % 360;
-    if (diff > 180) {
-      return diff - 360;
-    } else if (diff < -180) {
-      return diff + 360;
-    }
-    return diff;
-  }
-  calculateError_(param) {
-    switch (param) {
-      case "meanAnomaly":
-        return this.currentParams_.latitude - this.goalParams_.latitude;
-      case "raan":
-        return this.normalizeAngleDifference_(
-          this.currentParams_.longitude,
-          this.goalParams_.longitude
-        );
-      case "argOfPerigee":
-        this.debug_(`Current altitude: ${this.currentParams_.altitude} - Goal altitude: ${this.goalParams_.altitude}`);
-        return this.currentParams_.altitude - this.goalParams_.altitude;
-      default:
-        return 0;
-    }
-  }
-  updateOrbitWithoutDirectionCheck_(newParams) {
-    const tle1 = this.generateTle1_();
-    const tle2 = this.generateTle2_(newParams);
-    const satrec = Sgp4.createSatrec(tle1, tle2);
-    if (!satrec) {
-      throw new Error("Invalid orbit parameters");
-    }
-    const { m, gmst } = this.calculateTimeVariables_(this.now_, satrec);
-    if (m === null) {
-      throw new Error("Invalid time variables");
-    }
-    const positionEci = Sgp4.propagate(satrec, m).position;
-    const { lat, lon, alt } = eci2lla(positionEci, gmst);
-    this.currentParams_ = {
-      ...this.currentParams_,
-      ...newParams,
-      latitude: lat,
-      longitude: lon,
-      altitude: alt
-    };
-  }
-  findPerigeePosition_() {
-    let lowestAltitude = Infinity;
-    let perigeeParams = null;
-    for (let meanA = 0; meanA < 360; meanA += 0.05) {
-      const tle1 = this.generateTle1_();
-      const tle2 = this.generateTle2_({ meanAnomaly: meanA });
-      const satrec = Sgp4.createSatrec(tle1, tle2);
-      if (!satrec) {
-        continue;
-      }
-      const { m, gmst } = this.calculateTimeVariables_(this.now_, satrec);
-      if (m === null) {
-        throw new Error("Invalid time variables");
-      }
-      const positionEci = Sgp4.propagate(satrec, m).position;
-      const { lat, lon, alt } = eci2lla(positionEci, gmst);
-      if (alt < lowestAltitude) {
-        lowestAltitude = alt;
-        perigeeParams = {
-          meanAnomaly: meanA,
-          argOfPerigee: this.currentParams_.argOfPerigee,
-          raan: this.currentParams_.raan,
-          altitude: alt,
-          latitude: lat,
-          longitude: lon
-        };
+    const fineMs = this.options_.fineStepSec * 1e3;
+    const refineStart = Math.max(startMs, bestMs - coarseMs);
+    const refineEnd = Math.min(endMs, bestMs + coarseMs);
+    for (let ms = refineStart; ms <= refineEnd; ms += fineMs) {
+      const error = Math.abs(this.raanErrorAt_(new Date(ms)));
+      if (error < bestError) {
+        bestError = error;
+        bestMs = ms;
       }
     }
-    if (!perigeeParams) {
-      throw new Error("Failed to find perigee position");
-    }
-    this.debug_(`Found perigee at altitude ${perigeeParams.altitude} km`);
-    return perigeeParams;
+    const time = new Date(bestMs);
+    const achievableRaan = this.achievableRaan(time);
+    const targetRaan = this.targetRaanAt_(time);
+    return {
+      time,
+      achievableRaan,
+      targetRaan,
+      raanError: _LaunchWindowFinder.normalize180_(achievableRaan - targetRaan)
+    };
   }
   /**
-   * 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.
+   * 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.
    */
-  tleSatNum_() {
-    return this.sat_.tle1.substring(2, 7);
+  static meanRaanAt(satrec, time) {
+    const minutesSinceEpoch = (_LaunchWindowFinder.julianDate_(time) - satrec.jdsatepoch) * MINUTES_PER_DAY;
+    return _LaunchWindowFinder.normalizeDeg_((satrec.nodeo + satrec.nodedot * minutesSinceEpoch) * RAD2DEG);
   }
-  generateTle1_() {
-    return `1 ${this.tleSatNum_()}U ${this.sat_.tle1.substring(9, 17)} ${this.sat_.tle1.substring(18, 32)}${this.sat_.tle1.substring(32, 71)}`;
+  targetRaanAt_(time) {
+    const target = this.options_.targetRaan;
+    return typeof target === "function" ? target(time) : target;
   }
-  generateTle2_(newParams) {
-    const mergedParams = {
-      ...this.currentParams_,
-      // Use current parameters as base
-      ...newParams
-      // Override with any provided parameters
-    };
-    const inc = this.sat_.inclination.toFixed(4).padStart(8, "0");
-    const raan = mergedParams.raan.toFixed(4).padStart(8, "0");
-    const ecc = this.sat_.eccentricity.toFixed(7).substring(2, 9);
-    const argPer = mergedParams.argOfPerigee.toFixed(4).padStart(8, "0");
-    const meanA = mergedParams.meanAnomaly.toFixed(4).padStart(8, "0");
-    const meanMo = this.sat_.tle2.substring(52, 63);
-    return `2 ${this.tleSatNum_()} ${inc} ${raan} ${ecc} ${argPer} ${meanA} ${meanMo}    10`;
+  raanErrorAt_(time) {
+    return _LaunchWindowFinder.normalize180_(this.achievableRaan(time) - this.targetRaanAt_(time));
+  }
+  static julianDate_(time) {
+    return jday(time.getUTCFullYear(), time.getUTCMonth() + 1, time.getUTCDate(), time.getUTCHours(), time.getUTCMinutes(), time.getUTCSeconds()) + time.getUTCMilliseconds() * MILLISECONDS_TO_DAYS;
+  }
+  static normalizeDeg_(deg) {
+    return (deg % 360 + 360) % 360;
+  }
+  static normalize180_(deg) {
+    const normalized = (deg % 360 + 360) % 360;
+    return normalized >= 180 ? normalized - 360 : normalized;
   }
 };
 
+// src/orbit-design/GroundTrackStateVector.ts
+var WGS84_A = 6378.137;
+var WGS84_F = 1 / 298.257223563;
+var WGS84_E2 = 2 * WGS84_F - WGS84_F * WGS84_F;
+var MIN_ECCENTRICITY = 1e-3;
+var groundTrackStateVector = (opts) => {
+  const { semimajorAxisKm: a, inclinationRad: inc, latRad, lonRad, gmstRad, direction } = opts;
+  const e = Math.max(opts.eccentricity, MIN_ECCENTRICITY);
+  const rPerigee = a * (1 - e);
+  const vPerigee = Math.sqrt(Earth.mu / a * ((1 + e) / (1 - e)));
+  const sinLat = Math.sin(latRad);
+  const cosLat = Math.cos(latRad);
+  const nPrime = WGS84_A / Math.sqrt(1 - WGS84_E2 * sinLat * sinLat);
+  const mPrime = nPrime * (1 - WGS84_E2);
+  const c = cosLat * cosLat;
+  const s = sinLat * sinLat;
+  const bCoef = c * nPrime + s * mPrime;
+  const cCoef = c * nPrime * nPrime + s * mPrime * mPrime - rPerigee * rPerigee;
+  const disc = bCoef * bCoef - cCoef;
+  if (disc < 0) {
+    return null;
+  }
+  const height = -bCoef + Math.sqrt(disc);
+  const cosLonE = Math.cos(lonRad);
+  const sinLonE = Math.sin(lonRad);
+  const xEcef = (nPrime + height) * cosLat * cosLonE;
+  const yEcef = (nPrime + height) * cosLat * sinLonE;
+  const zEcef = (mPrime + height) * sinLat;
+  const cosG = Math.cos(gmstRad);
+  const sinG = Math.sin(gmstRad);
+  const position = {
+    x: xEcef * cosG - yEcef * sinG,
+    y: xEcef * sinG + yEcef * cosG,
+    z: zEcef
+  };
+  const rMag = Math.hypot(position.x, position.y, position.z);
+  const rHat = { x: position.x / rMag, y: position.y / rMag, z: position.z / rMag };
+  const geocentricLat = Math.asin(rHat.z);
+  const cosGeoLat = Math.cos(geocentricLat);
+  const sinAz = Math.cos(inc) / cosGeoLat;
+  if (sinAz < -1 || sinAz > 1) {
+    return null;
+  }
+  const cosAz = (direction === "N" ? 1 : -1) * Math.sqrt(Math.max(0, 1 - sinAz * sinAz));
+  const eastMag = Math.hypot(rHat.x, rHat.y);
+  const eastHat = eastMag > 1e-9 ? { x: -rHat.y / eastMag, y: rHat.x / eastMag, z: 0 } : { x: 1, y: 0, z: 0 };
+  const northHat = {
+    x: rHat.y * eastHat.z - rHat.z * eastHat.y,
+    y: rHat.z * eastHat.x - rHat.x * eastHat.z,
+    z: rHat.x * eastHat.y - rHat.y * eastHat.x
+  };
+  const velocity = {
+    x: vPerigee * (sinAz * eastHat.x + cosAz * northHat.x),
+    y: vPerigee * (sinAz * eastHat.y + cosAz * northHat.y),
+    z: vPerigee * (sinAz * eastHat.z + cosAz * northHat.z)
+  };
+  return { position, velocity };
+};
+var semimajorAxisFromMeanMotion = (meanMotionRevPerDay) => {
+  const n = meanMotionRevPerDay * 2 * Math.PI / 86400;
+  return (Earth.mu / (n * n)) ** (1 / 3);
+};
+var perigeeSpeed = (semimajorAxisKm, eccentricity) => Math.sqrt(Earth.mu / semimajorAxisKm * ((1 + eccentricity) / (1 - eccentricity)));
+
 // src/orbit-design/RepeatGroundTrack.ts
 var SUN_SYNC_PRECESSION_RAD_PER_SEC = 0.9856 * DEG2RAD / secondsPerDay;
 var RepeatGroundTrack = class _RepeatGroundTrack {
@@ -30222,6 +30684,688 @@ var RepeatGroundTrack = class _RepeatGroundTrack {
     return a;
   }
 };
+
+// src/external/Sgp4WasmBase.ts
+var DS50_UTC_JD_EPOCH = 24332815e-1;
+var ERR_SAT_TEXT_BYTES = 512;
+var Sgp4WasmBase = class _Sgp4WasmBase {
+  module_ = null;
+  fs_ = null;
+  bindings_ = null;
+  loadPromise_ = null;
+  isDynArrInitialized_ = false;
+  scratchKeyPtr_ = 0;
+  scratchResultPtr_ = 0;
+  /**
+   * 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) {
+    return epoch.toJulianDate() - DS50_UTC_JD_EPOCH;
+  }
+  /**
+   * Whether the wasm runtime has been loaded and initialized.
+   */
+  get isLoaded() {
+    return this.module_ !== null;
+  }
+  /**
+   * Raw Emscripten Module escape hatch (`_malloc`, `ccall`, heap views, ...).
+   * @throws {Sgp4WasmError} If the module is not loaded yet.
+   */
+  get module() {
+    if (!this.module_) {
+      throw new Sgp4WasmError(`${this.constructor.name} is not loaded. Call load() first.`);
+    }
+    return this.module_;
+  }
+  /**
+   * Raw Emscripten virtual filesystem escape hatch.
+   * @throws {Sgp4WasmError} If the module is not loaded yet.
+   */
+  get fs() {
+    if (!this.fs_) {
+      throw new Sgp4WasmError(`${this.constructor.name} is not loaded. Call load() first.`);
+    }
+    return this.fs_;
+  }
+  /**
+   * 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 = {}) {
+    this.loadPromise_ ??= this.loadInternal_(options).catch((err) => {
+      this.loadPromise_ = null;
+      throw err;
+    });
+    return this.loadPromise_;
+  }
+  /**
+   * 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() {
+    if (this.isDynArrInitialized_ && this.bindings_) {
+      this.bindings_.freeDynArr();
+    }
+    if (this.module_ && this.scratchKeyPtr_) {
+      this.module_._free(this.scratchKeyPtr_);
+      this.module_._free(this.scratchResultPtr_);
+    }
+    this.scratchKeyPtr_ = 0;
+    this.scratchResultPtr_ = 0;
+    this.isDynArrInitialized_ = false;
+    this.module_ = null;
+    this.fs_ = null;
+    this.bindings_ = null;
+    this.loadPromise_ = null;
+  }
+  // TLE tree management
+  /**
+   * 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, line2) {
+    const satKey = this.fn_().tleAddSatFrLines(line1, line2);
+    if (satKey <= 0n) {
+      throw new Sgp4WasmError(`TleAddSatFrLines_wasm failed for line1 "${line1}" (code ${satKey})`, Number(satKey));
+    }
+    return 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) {
+    const m = this.module;
+    const numSats = _Sgp4WasmBase.countTles_(tleText);
+    if (numSats === 0) {
+      return [];
+    }
+    const textBytes = new TextEncoder().encode(tleText);
+    return this.withMalloc_(textBytes.length + 1, (textPtr) => this.withMalloc_(numSats * 8, (keysPtr) => this.withMalloc_(ERR_SAT_TEXT_BYTES, (errPtr) => {
+      m.HEAPU8.set(textBytes, textPtr);
+      m.HEAPU8[textPtr + textBytes.length] = 0;
+      m.HEAPU8.fill(0, errPtr, errPtr + ERR_SAT_TEXT_BYTES);
+      const ret = this.fn_().tleAddSatsFrLines(textPtr, keysPtr, errPtr);
+      if (ret !== 0) {
+        const errLine = m.UTF8ToString(errPtr, ERR_SAT_TEXT_BYTES);
+        throw new Sgp4WasmError(`TleAddSatsFrLines_wasm failed (code ${ret}); offending TLE line 1: "${errLine}"`, ret);
+      }
+      return this.readI64Array_(keysPtr, numSats);
+    })));
+  }
+  /**
+   * 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) {
+    this.fn_();
+    const vfs = this.fs;
+    try {
+      vfs.writeFile("inFile", tleText);
+      const ret = this.fn_().tleLoadFileVfs("inFile");
+      if (ret <= 0) {
+        throw new Sgp4WasmError(`TleLoadFileVFS_wasm failed (code ${ret})`, ret);
+      }
+      const outText = vfs.readFile("outFile", { encoding: "utf8" });
+      return outText.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => BigInt(line));
+    } finally {
+      for (const file of ["inFile", "outFile"]) {
+        if (vfs.analyzePath(file).exists) {
+          vfs.unlink(file);
+        }
+      }
+    }
+  }
+  /**
+   * Removes TLEs from the TLE tree (`TleRemoveSats_wasm`).
+   * @param satKeys The satKeys to remove.
+   */
+  removeSats(satKeys) {
+    this.runKeysWithErrSat_((keysPtr, numKeys, errPtr) => this.fn_().tleRemoveSats(keysPtr, numKeys, errPtr), satKeys, "TleRemoveSats_wasm");
+  }
+  // SGP4 object lifecycle
+  /**
+   * 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) {
+    this.runKeysWithErrSat_((keysPtr, numKeys, errPtr) => this.fn_().sgp4InitSats(keysPtr, numKeys, errPtr), satKeys, "Sgp4InitSats_wasm");
+  }
+  /**
+   * Removes initialized SGP4 objects (`Sgp4RemoveSats_wasm`).
+   * @param satKeys The satKeys to remove.
+   */
+  uninitSats(satKeys) {
+    this.runKeysWithErrSat_((keysPtr, numKeys, errPtr) => this.fn_().sgp4RemoveSats(keysPtr, numKeys, errPtr), satKeys, "Sgp4RemoveSats_wasm");
+  }
+  // Propagation by satKey
+  /**
+   * 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, startTimeMse, propsPerSat, stepSizeMin) {
+    const buf = this.propagateKeys_(
+      (...args) => this.fn_().sgp4Prop(...args),
+      satKeys,
+      startTimeMse,
+      propsPerSat,
+      stepSizeMin,
+      11,
+      "Sgp4Prop_wasm"
+    );
+    return this.parseRecords_(buf, satKeys.length, propsPerSat, 11);
+  }
+  /**
+   * 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, startTimeMse, propsPerSat, stepSizeMin) {
+    const buf = this.propagateKeys_(
+      (...args) => this.fn_().sgp4PropPosVel(...args),
+      satKeys,
+      startTimeMse,
+      propsPerSat,
+      stepSizeMin,
+      8,
+      "Sgp4PropPosVel_wasm"
+    );
+    return this.parseRecords_(buf, satKeys.length, propsPerSat, 8);
+  }
+  /**
+   * 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, startTimeDs50Utc, propsPerSat, stepSizeMin) {
+    const buf = this.propagateKeys_(
+      (...args) => this.fn_().sgp4PropDs50Utc(...args),
+      satKeys,
+      startTimeDs50Utc,
+      propsPerSat,
+      stepSizeMin,
+      11,
+      "Sgp4PropDs50Utc_wasm"
+    );
+    return this.parseRecords_(buf, satKeys.length, propsPerSat, 11);
+  }
+  /**
+   * 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, startTimeDs50Utc, propsPerSat, stepSizeMin) {
+    const buf = this.propagateKeys_(
+      (...args) => this.fn_().sgp4PropDs50UtcPosVel(...args),
+      satKeys,
+      startTimeDs50Utc,
+      propsPerSat,
+      stepSizeMin,
+      8,
+      "Sgp4PropDs50UtcPosVel_wasm"
+    );
+    return this.parseRecords_(buf, satKeys.length, propsPerSat, 8);
+  }
+  /**
+   * 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, minutesSinceEpoch) {
+    return this.propagate([satKey], minutesSinceEpoch, 1, 0)[0][0];
+  }
+  /**
+   * 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, epoch) {
+    return this.propagateDs50Utc([satKey], _Sgp4WasmBase.toDs50Utc(epoch), 1, 0)[0][0];
+  }
+  /**
+   * 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, minutesSinceEpoch) {
+    this.fn_();
+    const m = this.module;
+    if (!this.scratchKeyPtr_) {
+      this.scratchKeyPtr_ = m._malloc(8);
+      this.scratchResultPtr_ = m._malloc(8 * 8);
+    }
+    m.HEAP64[this.scratchKeyPtr_ >> 3] = satKey;
+    const ret = m._Sgp4PropPosVel_wasm(this.scratchKeyPtr_, 1, minutesSinceEpoch, 1, 0, this.scratchResultPtr_);
+    if (ret !== 0) {
+      return { err: ret, position: { x: 0, y: 0, z: 0 }, velocity: { x: 0, y: 0, z: 0 } };
+    }
+    const heap = m.HEAPF64;
+    const off = this.scratchResultPtr_ / 8;
+    return {
+      err: heap[off],
+      position: { x: heap[off + 2], y: heap[off + 3], z: heap[off + 4] },
+      velocity: { x: heap[off + 5], y: heap[off + 6], z: heap[off + 7] }
+    };
+  }
+  // Dynamic array batch path
+  /**
+   * Initializes the module-global dynamic array of SGP4 objects
+   * (`InitDynArr_wasm`).
+   * @param initialSize Initial capacity of the array.
+   */
+  initDynArr(initialSize) {
+    const ret = this.fn_().initDynArr(initialSize);
+    if (ret !== 0) {
+      throw new Sgp4WasmError(`InitDynArr_wasm failed (code ${ret}): ${SGP4_WASM_DYN_ARR_ERRORS[ret] ?? "unknown error"}`, ret);
+    }
+    this.isDynArrInitialized_ = true;
+  }
+  /**
+   * Re-allocates the dynamic array to a new capacity
+   * (`ReallocateDynArr_wasm`).
+   * @param newSize New capacity of the array.
+   */
+  reallocDynArr(newSize) {
+    const ret = this.fn_().reallocDynArr(newSize);
+    if (ret !== 0) {
+      throw new Sgp4WasmError(`ReallocateDynArr_wasm failed (code ${ret}): ${SGP4_WASM_DYN_ARR_ERRORS[ret] ?? "unknown error"}`, ret);
+    }
+  }
+  /**
+   * Frees the dynamic array (`FreeDynArr_wasm`).
+   */
+  freeDynArr() {
+    this.fn_().freeDynArr();
+    this.isDynArrInitialized_ = false;
+  }
+  /**
+   * Current size of the dynamic array (`GetDynArrSize_wasm`).
+   */
+  get dynArrSize() {
+    return this.fn_().getDynArrSize();
+  }
+  /**
+   * 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, line2) {
+    const index = this.fn_().addSatToDynArr(line1, line2);
+    if (index < 0) {
+      throw new Sgp4WasmError(`AddSatToDynArr_wasm failed (code ${index}): ${SGP4_WASM_ADD_SAT_ERRORS[index] ?? "unknown error"}`, index);
+    }
+    return index;
+  }
+  /**
+   * 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, startTimeMse, propsPerSat, stepSizeMin) {
+    const buf = this.propagateIndexes_(
+      (...args) => this.fn_().sgp4PropDynArrPosVel(...args),
+      indexes,
+      startTimeMse,
+      propsPerSat,
+      stepSizeMin,
+      8
+    );
+    return this.parseRecords_(buf, indexes.length, propsPerSat, 8);
+  }
+  /**
+   * 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, startTimeDs50Utc, propsPerSat, stepSizeMin) {
+    const buf = this.propagateIndexes_(
+      (...args) => this.fn_().sgp4PropDs50UtcDynArr(...args),
+      indexes,
+      startTimeDs50Utc,
+      propsPerSat,
+      stepSizeMin,
+      11
+    );
+    return this.parseRecords_(buf, indexes.length, propsPerSat, 11);
+  }
+  /**
+   * 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, startTimeDs50Utc, propsPerSat, stepSizeMin) {
+    const buf = this.propagateIndexes_(
+      (...args) => this.fn_().sgp4PropDs50UtcDynArrPosVel(...args),
+      indexes,
+      startTimeDs50Utc,
+      propsPerSat,
+      stepSizeMin,
+      8
+    );
+    return this.parseRecords_(buf, indexes.length, propsPerSat, 8);
+  }
+  // Logging
+  /**
+   * Sets the wasm library's logging level (`SetLogLevel_wasm`).
+   * @param level The new log level.
+   */
+  setLogLevel(level) {
+    const ret = this.fn_().setLogLevel(level);
+    if (ret !== 0) {
+      throw new Sgp4WasmError(`SetLogLevel_wasm failed (code ${ret})`, ret);
+    }
+  }
+  // Internals
+  /**
+   * Counts the TLEs in newline-separated text by counting line-1 rows.
+   * @param tleText Newline-separated TLE lines.
+   * @returns Number of TLEs.
+   */
+  static countTles_(tleText) {
+    return tleText.split(/\r?\n/u).filter((line) => line.trim().startsWith("1 ")).length;
+  }
+  static isHttpUrl_(source) {
+    const href = source instanceof URL ? source.href : source;
+    return /^https?:\/\//u.test(href);
+  }
+  fn_() {
+    if (!this.bindings_) {
+      throw new Sgp4WasmError(`${this.constructor.name} is not loaded. Call load() first.`);
+    }
+    return this.bindings_;
+  }
+  async loadInternal_(options) {
+    const isNode = typeof process !== "undefined" && Boolean(process.versions?.node);
+    const glueText = await this.resolveGlueText_(options.glue, isNode);
+    const wasmBinary = await this.resolveWasmBinary_(options.wasm, isNode);
+    let requireFn;
+    let dirname;
+    if (isNode) {
+      const nodeModule = await import(
+        /* webpackIgnore: true */
+        'module'
+      );
+      requireFn = nodeModule.createRequire(importMetaUrl);
+      dirname = ".";
+    }
+    let markReady = () => void 0;
+    let markFailed = () => void 0;
+    const runtimeReady = new Promise((resolve, reject) => {
+      markReady = resolve;
+      markFailed = reject;
+    });
+    const seed = {
+      wasmBinary,
+      onRuntimeInitialized: () => markReady(),
+      onAbort: (reason) => markFailed(new Sgp4WasmError(`${this.constructor.name} wasm runtime aborted: ${reason}`))
+    };
+    if (options.print) {
+      seed.print = options.print;
+    }
+    if (options.printErr) {
+      seed.printErr = options.printErr;
+    }
+    const evaluateGlue = new Function("Module", "require", "__dirname", `${glueText};
+return { Module: Module, FS: FS };`);
+    const { Module, FS } = evaluateGlue(seed, requireFn, dirname);
+    await runtimeReady;
+    this.module_ = Module;
+    this.fs_ = FS;
+    this.bindings_ = _Sgp4WasmBase.buildBindings_(Module);
+    return this;
+  }
+  static buildBindings_(m) {
+    const num = "number";
+    return {
+      tleAddSatFrLines: m.cwrap("TleAddSatFrLines_wasm", num, ["string", "string"]),
+      tleAddSatsFrLines: m.cwrap("TleAddSatsFrLines_wasm", num, [num, num, num]),
+      tleLoadFileVfs: m.cwrap("TleLoadFileVFS_wasm", num, ["string"]),
+      tleRemoveSats: m.cwrap("TleRemoveSats_wasm", num, [num, num, num]),
+      sgp4InitSats: m.cwrap("Sgp4InitSats_wasm", num, [num, num, num]),
+      sgp4RemoveSats: m.cwrap("Sgp4RemoveSats_wasm", num, [num, num, num]),
+      sgp4Prop: m.cwrap("Sgp4Prop_wasm", num, [num, num, num, num, num, num]),
+      sgp4PropPosVel: m.cwrap("Sgp4PropPosVel_wasm", num, [num, num, num, num, num, num]),
+      sgp4PropDs50Utc: m.cwrap("Sgp4PropDs50Utc_wasm", num, [num, num, num, num, num, num]),
+      sgp4PropDs50UtcPosVel: m.cwrap("Sgp4PropDs50UtcPosVel_wasm", num, [num, num, num, num, num, num]),
+      initDynArr: m.cwrap("InitDynArr_wasm", num, [num]),
+      reallocDynArr: m.cwrap("ReallocateDynArr_wasm", num, [num]),
+      freeDynArr: m.cwrap("FreeDynArr_wasm", null, []),
+      getDynArrSize: m.cwrap("GetDynArrSize_wasm", num, []),
+      addSatToDynArr: m.cwrap("AddSatToDynArr_wasm", num, ["string", "string"]),
+      sgp4PropDynArrPosVel: m.cwrap("Sgp4PropDynArrPosVel_wasm", null, [num, num, num, num, num, num]),
+      sgp4PropDs50UtcDynArr: m.cwrap("Sgp4PropDs50UtcDynArr_wasm", null, [num, num, num, num, num, num]),
+      sgp4PropDs50UtcDynArrPosVel: m.cwrap("Sgp4PropDs50UtcDynArrPosVel_wasm", null, [num, num, num, num, num, num]),
+      setLogLevel: m.cwrap("SetLogLevel_wasm", num, [num])
+    };
+  }
+  async resolveGlueText_(source, isNode) {
+    if (source && typeof source === "object" && "text" in source) {
+      return source.text;
+    }
+    const resolved = this.resolveDefaultSource_(source, this.defaultGlueFile_, isNode);
+    if (isNode && !_Sgp4WasmBase.isHttpUrl_(resolved)) {
+      return await this.readNodeFile_(resolved, "utf8");
+    }
+    const response = await fetch(resolved);
+    if (!response.ok) {
+      throw this.missingArtifactError_(resolved.toString(), `HTTP ${response.status}`);
+    }
+    return response.text();
+  }
+  async resolveWasmBinary_(source, isNode) {
+    if (source instanceof Uint8Array || source instanceof ArrayBuffer) {
+      return source;
+    }
+    const resolved = this.resolveDefaultSource_(source, this.defaultWasmFile_, isNode);
+    if (isNode && !_Sgp4WasmBase.isHttpUrl_(resolved)) {
+      return await this.readNodeFile_(resolved, null);
+    }
+    const response = await fetch(resolved);
+    if (!response.ok) {
+      throw this.missingArtifactError_(resolved.toString(), `HTTP ${response.status}`);
+    }
+    return response.arrayBuffer();
+  }
+  resolveDefaultSource_(source, defaultFile, isNode) {
+    if (source) {
+      return source;
+    }
+    if (!isNode || typeof importMetaUrl !== "string") {
+      throw new Sgp4WasmError(
+        `${this.constructor.name}.load() requires explicit glue/wasm sources in this environment. Serve the ${defaultFile} artifact as a static asset and pass its URL via LoadOptions.`
+      );
+    }
+    return new URL(defaultFile, importMetaUrl);
+  }
+  async readNodeFile_(source, encoding) {
+    const fsPromises = await import(
+      /* webpackIgnore: true */
+      'fs/promises'
+    );
+    try {
+      return encoding ? await fsPromises.readFile(source, encoding) : await fsPromises.readFile(source);
+    } catch (err) {
+      throw this.missingArtifactError_(source.toString(), err.message);
+    }
+  }
+  missingArtifactError_(location, cause) {
+    return new Sgp4WasmError(
+      `Failed to load Sgp4Prop artifact at ${location} (${cause}). The Sgp4Prop WebAssembly artifacts are part of the license-restricted USSF Astro Standards "C Sgp4Prop WebAssembly" distribution available from space-track.org. Download it and place ${this.defaultGlueFile_}/${this.defaultWasmFile_} in ootk's src/external/ directory, or pass explicit sources via LoadOptions.`
+    );
+  }
+  // Memory marshalling
+  withMalloc_(bytes, fn) {
+    const m = this.module;
+    const ptr = m._malloc(Math.max(bytes, 1));
+    try {
+      return fn(ptr);
+    } finally {
+      m._free(ptr);
+    }
+  }
+  withI64Array_(values, fn) {
+    return this.withMalloc_(values.length * 8, (ptr) => {
+      const m = this.module;
+      values.forEach((value, i) => m.setValue(ptr + i * 8, BigInt(value), "i64"));
+      return fn(ptr);
+    });
+  }
+  withI32Array_(values, fn) {
+    return this.withMalloc_(values.length * 4, (ptr) => {
+      const m = this.module;
+      values.forEach((value, i) => m.setValue(ptr + i * 4, value, "i32"));
+      return fn(ptr);
+    });
+  }
+  readI64Array_(ptr, count) {
+    const m = this.module;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      out.push(m.getValue(ptr + i * 8, "i64"));
+    }
+    return out;
+  }
+  /**
+   * 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.
+   */
+  withF64Result_(count, fn) {
+    return this.withMalloc_(count * 8, (ptr) => {
+      fn(ptr);
+      return this.module.HEAPF64.slice(ptr / 8, ptr / 8 + count);
+    });
+  }
+  runKeysWithErrSat_(op, satKeys, opName) {
+    this.withI64Array_(satKeys, (keysPtr) => this.withMalloc_(8, (errPtr) => {
+      const m = this.module;
+      m.setValue(errPtr, 0n, "i64");
+      const ret = op(keysPtr, satKeys.length, errPtr);
+      if (ret !== 0) {
+        const errKey = m.getValue(errPtr, "i64");
+        throw new Sgp4WasmError(`${opName} failed (code ${ret}); offending satKey: ${errKey}`, ret);
+      }
+    }));
+  }
+  propagateKeys_(op, satKeys, start, propsPerSat, stepMin, width, opName) {
+    return this.withI64Array_(satKeys, (keysPtr) => this.withF64Result_(satKeys.length * propsPerSat * width, (resultPtr) => {
+      const ret = op(keysPtr, satKeys.length, start, propsPerSat, stepMin, resultPtr);
+      if (ret !== 0) {
+        throw new Sgp4WasmError(`${opName} failed (code ${ret})`, ret);
+      }
+    }));
+  }
+  propagateIndexes_(op, indexes, start, propsPerSat, stepMin, width) {
+    return this.withI32Array_(indexes, (idxPtr) => this.withF64Result_(indexes.length * propsPerSat * width, (resultPtr) => {
+      op(idxPtr, indexes.length, start, propsPerSat, stepMin, resultPtr);
+    }));
+  }
+  /**
+   * 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.
+   */
+  parseRecords_(buf, numKeys, propsPerSat, width) {
+    const results = [];
+    for (let satIndex = 0; satIndex < numKeys; satIndex++) {
+      const satRecords = [];
+      for (let stepIndex = 0; stepIndex < propsPerSat; stepIndex++) {
+        const off = (satIndex * propsPerSat + stepIndex) * width;
+        const record = {
+          err: buf[off],
+          time: buf[off + 1],
+          position: new Vector3D(buf[off + 2], buf[off + 3], buf[off + 4]),
+          velocity: new Vector3D(
+            buf[off + 5],
+            buf[off + 6],
+            buf[off + 7]
+          )
+        };
+        if (width === 11) {
+          record.llh = {
+            lat: buf[off + 8],
+            lon: buf[off + 9],
+            height: buf[off + 10]
+          };
+        }
+        satRecords.push(record);
+      }
+      results.push(satRecords);
+    }
+    return results;
+  }
+};
+
+// src/external/Sgp4Wasm.ts
+var Sgp4Wasm = class extends Sgp4WasmBase {
+  defaultGlueFile_ = "Sgp4Prop.js";
+  defaultWasmFile_ = "Sgp4Prop.wasm";
+};
+
+// src/external/Sgp4XpWasm.ts
+var Sgp4XpWasm = class extends Sgp4WasmBase {
+  defaultGlueFile_ = "Sgp4Prop.xp.js";
+  defaultWasmFile_ = "Sgp4Prop.xp.wasm";
+};
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -30395,6 +31539,22 @@ var RepeatGroundTrack = class _RepeatGroundTrack {
  * 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/>.
  */
+/**
+ * @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/>.
+ */
 /*! Bundled license information:
 
 astronomy-engine/esm/astronomy.js:
@@ -30518,6 +31678,7 @@ exports.LambertIOD = LambertIOD;
 exports.LandObject = LandObject;
 exports.LaserRangingSensor = LaserRangingSensor;
 exports.LaunchTrajectoryGenerator = LaunchTrajectoryGenerator;
+exports.LaunchWindowFinder = LaunchWindowFinder;
 exports.LevenbergMarquardtOD = LevenbergMarquardtOD;
 exports.LevenbergMarquardtResult = LevenbergMarquardtResult;
 exports.MILLISECONDS_PER_DAY = MILLISECONDS_PER_DAY;
@@ -30544,7 +31705,6 @@ exports.OmmParser = OmmParser;
 exports.OotkError = OotkError;
 exports.OpticalSensor = OpticalSensor;
 exports.OrbitDeterminationError = OrbitDeterminationError;
-exports.OrbitFinder = OrbitFinder;
 exports.OrbitRegime = OrbitRegime;
 exports.PI = PI;
 exports.ParseError = ParseError;
@@ -30560,6 +31720,7 @@ exports.ProbabilityOfCollision = ProbabilityOfCollision;
 exports.PropagationError = PropagationError;
 exports.Propagator = Propagator;
 exports.PropagatorType = PropagatorType;
+exports.PropellantBudget = PropellantBudget;
 exports.Quaternion = Quaternion;
 exports.RAD2DEG = RAD2DEG;
 exports.RADIUS_OF_EARTH = RADIUS_OF_EARTH;
@@ -30580,6 +31741,8 @@ exports.RkResult = RkResult;
 exports.RungeKutta4Propagator = RungeKutta4Propagator;
 exports.RungeKutta89Propagator = RungeKutta89Propagator;
 exports.RungeKuttaAdaptive = RungeKuttaAdaptive;
+exports.SGP4_WASM_ADD_SAT_ERRORS = SGP4_WASM_ADD_SAT_ERRORS;
+exports.SGP4_WASM_DYN_ARR_ERRORS = SGP4_WASM_DYN_ARR_ERRORS;
 exports.SLR_WAVELENGTHS = SLR_WAVELENGTHS;
 exports.SPEED_OF_LIGHT_KM_S = SPEED_OF_LIGHT_KM_S;
 exports.Satellite = Satellite;
@@ -30594,6 +31757,12 @@ exports.Sgp4Error = Sgp4Error;
 exports.Sgp4ErrorCode = Sgp4ErrorCode;
 exports.Sgp4OpsMode = Sgp4OpsMode;
 exports.Sgp4Propagator = Sgp4Propagator;
+exports.Sgp4Wasm = Sgp4Wasm;
+exports.Sgp4WasmBase = Sgp4WasmBase;
+exports.Sgp4WasmError = Sgp4WasmError;
+exports.Sgp4WasmLogLevel = Sgp4WasmLogLevel;
+exports.Sgp4WasmPropagator = Sgp4WasmPropagator;
+exports.Sgp4XpWasm = Sgp4XpWasm;
 exports.SimpleLinearRegression = SimpleLinearRegression;
 exports.SolarRadiationPressure = SolarRadiationPressure;
 exports.SolarSystem = SolarSystem;
@@ -30614,6 +31783,7 @@ exports.TimeStamped = TimeStamped;
 exports.Tle = Tle;
 exports.Transmitter = Transmitter;
 exports.Transponder = Transponder;
+exports.TtcAntenna = TtcAntenna;
 exports.TwoBurnOrbitTransfer = TwoBurnOrbitTransfer;
 exports.Uranus = Uranus;
 exports.ValidationError = ValidationError;
@@ -30677,6 +31847,7 @@ exports.getDegLat = getDegLat;
 exports.getDegLon = getDegLon;
 exports.getRadLat = getRadLat;
 exports.getRadLon = getRadLon;
+exports.groundTrackStateVector = groundTrackStateVector;
 exports.halfPi = halfPi;
 exports.isLeapYear = isLeapYear;
 exports.jacobian = jacobian;
@@ -30699,6 +31870,7 @@ exports.normalizeAngle = normalizeAngle;
 exports.observationDerivative = observationDerivative;
 exports.observationNoiseFromSigmas = observationNoiseFromSigmas;
 exports.parseCenterBody = parseCenterBody;
+exports.perigeeSpeed = perigeeSpeed;
 exports.rad2deg = rad2deg;
 exports.radecToPosition = radecToPosition;
 exports.radecToVelocity = radecToVelocity;
@@ -30718,6 +31890,7 @@ exports.sech = sech;
 exports.secondsPerDay = secondsPerDay;
 exports.secondsPerSiderealDay = secondsPerSiderealDay;
 exports.secondsPerWeek = secondsPerWeek;
+exports.semimajorAxisFromMeanMotion = semimajorAxisFromMeanMotion;
 exports.sez2rae = sez2rae;
 exports.sign = sign;
 exports.spaceObjType2Str = spaceObjType2Str;