@neilberkman/sidereon 0.15.0 → 0.16.0

package/pkg/sidereon.js

@@ -3234,6 +3234,51 @@ export class CoverageGrid {
 }
 if (Symbol.dispose) CoverageGrid.prototype[Symbol.dispose] = CoverageGrid.prototype.free;
 
+/**
+ * Stateful opt-in latch for SGP4 decay-like failures.
+ *
+ * Pass one latch per satellite to [`Tle.propagateWithDecayLatch`]. The first
+ * decay-like SGP4 failure records the requested epoch in minutes since the TLE
+ * epoch; later requests at the same or a later epoch throw immediately through
+ * the core latch instead of returning a raw post-decay state.
+ */
+export class DecayLatch {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DecayLatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_decaylatch_free(ptr, 0);
+    }
+    /**
+     * Clear the recorded decay state.
+     */
+    clear() {
+        wasm.decaylatch_clear(this.__wbg_ptr);
+    }
+    /**
+     * First observed decay-like epoch, in minutes since the TLE epoch.
+     * @returns {number | undefined}
+     */
+    get firstFailingEpochMinutes() {
+        const ret = wasm.decaylatch_firstFailingEpochMinutes(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Construct an empty decay latch.
+     */
+    constructor() {
+        const ret = wasm.decaylatch_new();
+        this.__wbg_ptr = ret;
+        DecayLatchFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) DecayLatch.prototype[Symbol.dispose] = DecayLatch.prototype.free;
+
 /**
  * SBAS degradation terms used when deriving an error model from a store.
  */
@@ -4111,6 +4156,36 @@ export class DtedTerrain {
 }
 if (Symbol.dispose) DtedTerrain.prototype[Symbol.dispose] = DtedTerrain.prototype.free;
 
+/**
+ * Earth figure used for conical eclipse shadow geometry.
+ * @enum {0 | 1}
+ */
+export const EarthShadowModel = Object.freeze({
+    /**
+     * Spherical Earth using the core mean Earth radius.
+     */
+    Spherical: 0, "0": "Spherical",
+    /**
+     * WGS84 oblate Earth approximation by polar-axis scaling.
+     */
+    Wgs84Oblate: 1, "1": "Wgs84Oblate",
+});
+
+/**
+ * EGM2008 raster spacing for NGA row-framed interpolation grids.
+ * @enum {0 | 1}
+ */
+export const Egm2008GridSpacing = Object.freeze({
+    /**
+     * The 1-arcminute EGM2008 grid.
+     */
+    OneMinute: 0, "0": "OneMinute",
+    /**
+     * The 2.5-arcminute EGM2008 grid.
+     */
+    TwoPointFiveMinute: 1, "1": "TwoPointFiveMinute",
+});
+
 /**
  * Loaded EGM96 15-arcminute geoid grid for explicit terrain datum conversion.
  */
@@ -4807,6 +4882,18 @@ export class FrameStates {
 }
 if (Symbol.dispose) FrameStates.prototype[Symbol.dispose] = FrameStates.prototype.free;
 
+/**
+ * WGS84 geodesic input failure class exposed as a stable enum symbol.
+ * @enum {0}
+ */
+export const GeodesicError = Object.freeze({
+    /**
+     * A latitude, longitude, azimuth, or distance was outside the accepted
+     * numeric domain.
+     */
+    InvalidInput: 0, "0": "InvalidInput",
+});
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -4850,6 +4937,49 @@ export class GeoidGrid {
         const ret = wasm.geoidgrid_ellipsoidalHeightRad(this.__wbg_ptr, orthometric_height_m, lat_rad, lon_rad);
         return ret;
     }
+    /**
+     * Parse a full NGA EGM2008 row-framed interpolation raster.
+     *
+     * The byte stream must contain one north-to-south Fortran sequential record
+     * per latitude row at the requested spacing. Use
+     * [`fromEgm2008RasterWindow`] for small cropped fixtures or partial loads.
+     * @param {Uint8Array} bytes
+     * @param {Egm2008GridSpacing} spacing
+     * @returns {GeoidGrid}
+     */
+    static fromEgm2008Raster(bytes, spacing) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geoidgrid_fromEgm2008Raster(ptr0, len0, spacing);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GeoidGrid.__wrap(ret[0]);
+    }
+    /**
+     * Parse a cropped NGA EGM2008 row-framed interpolation raster window.
+     *
+     * `latMinDeg` and `lonMinDeg` are the southwest node of the loaded grid.
+     * `nLat` and `nLon` are the latitude and longitude node counts in the byte
+     * stream. Queries use the same undulation methods as every other
+     * [`GeoidGrid`].
+     * @param {Uint8Array} bytes
+     * @param {Egm2008GridSpacing} spacing
+     * @param {number} lat_min_deg
+     * @param {number} lon_min_deg
+     * @param {number} n_lat
+     * @param {number} n_lon
+     * @returns {GeoidGrid}
+     */
+    static fromEgm2008RasterWindow(bytes, spacing, lat_min_deg, lon_min_deg, n_lat, n_lon) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.geoidgrid_fromEgm2008RasterWindow(ptr0, len0, spacing, lat_min_deg, lon_min_deg, n_lat, n_lon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GeoidGrid.__wrap(ret[0]);
+    }
     /**
      * Parse an EGM96 `WW15MGH.DAC` byte buffer into a full-resolution grid.
      * @param {Uint8Array} bytes
@@ -5583,6 +5713,239 @@ export class GroundTrack {
 }
 if (Symbol.dispose) GroundTrack.prototype[Symbol.dispose] = GroundTrack.prototype.free;
 
+/**
+ * Helmert parameters in the units used by the published catalog tables.
+ */
+export class HelmertParameters {
+    static __wrap(ptr) {
+        const obj = Object.create(HelmertParameters.prototype);
+        obj.__wbg_ptr = ptr;
+        HelmertParametersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HelmertParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_helmertparameters_free(ptr, 0);
+    }
+    /**
+     * Construct Helmert parameters from translation millimetres, scale parts
+     * per billion, and rotation milliarcseconds.
+     * @param {Float64Array} translation_mm
+     * @param {number} scale_ppb
+     * @param {Float64Array} rotation_mas
+     */
+    constructor(translation_mm, scale_ppb, rotation_mas) {
+        const ptr0 = passArrayF64ToWasm0(translation_mm, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(rotation_mas, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.helmertparameters_new(ptr0, len0, scale_ppb, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        HelmertParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Rotation components `[Rx, Ry, Rz]`, in milliarcseconds.
+     * @returns {Float64Array}
+     */
+    get rotationMas() {
+        const ret = wasm.helmertparameters_rotationMas(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Scale difference, in parts per billion.
+     * @returns {number}
+     */
+    get scalePpb() {
+        const ret = wasm.helmertparameters_scalePpb(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Translation components `[Tx, Ty, Tz]`, in millimetres.
+     * @returns {Float64Array}
+     */
+    get translationMm() {
+        const ret = wasm.helmertparameters_translationMm(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) HelmertParameters.prototype[Symbol.dispose] = HelmertParameters.prototype.free;
+
+/**
+ * Helmert parameter rates in the units used by the published catalog tables.
+ */
+export class HelmertRates {
+    static __wrap(ptr) {
+        const obj = Object.create(HelmertRates.prototype);
+        obj.__wbg_ptr = ptr;
+        HelmertRatesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HelmertRatesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_helmertrates_free(ptr, 0);
+    }
+    /**
+     * Construct Helmert parameter rates from translation millimetres per year,
+     * scale parts per billion per year, and rotation milliarcseconds per year.
+     * @param {Float64Array} translation_mm_per_year
+     * @param {number} scale_ppb_per_year
+     * @param {Float64Array} rotation_mas_per_year
+     */
+    constructor(translation_mm_per_year, scale_ppb_per_year, rotation_mas_per_year) {
+        const ptr0 = passArrayF64ToWasm0(translation_mm_per_year, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(rotation_mas_per_year, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.helmertrates_new(ptr0, len0, scale_ppb_per_year, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        HelmertRatesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Rotation rates `[Rx, Ry, Rz]`, in milliarcseconds per year.
+     * @returns {Float64Array}
+     */
+    get rotationMasPerYear() {
+        const ret = wasm.helmertrates_rotationMasPerYear(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Scale rate, in parts per billion per year.
+     * @returns {number}
+     */
+    get scalePpbPerYear() {
+        const ret = wasm.helmertrates_scalePpbPerYear(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Translation rates `[Tx, Ty, Tz]`, in millimetres per year.
+     * @returns {Float64Array}
+     */
+    get translationMmPerYear() {
+        const ret = wasm.helmertrates_translationMmPerYear(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+if (Symbol.dispose) HelmertRates.prototype[Symbol.dispose] = HelmertRates.prototype.free;
+
+/**
+ * One published 14-parameter Helmert catalog entry.
+ */
+export class HelmertTransform {
+    static __wrap(ptr) {
+        const obj = Object.create(HelmertTransform.prototype);
+        obj.__wbg_ptr = ptr;
+        HelmertTransformFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HelmertTransformFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_helmerttransform_free(ptr, 0);
+    }
+    /**
+     * Published source frame for the forward transform.
+     * @returns {TerrestrialFrame}
+     */
+    get from() {
+        const ret = wasm.helmerttransform_from(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Parameters at `referenceEpochYear`.
+     * @returns {HelmertParameters}
+     */
+    get parameters() {
+        const ret = wasm.helmerttransform_parameters(this.__wbg_ptr);
+        return HelmertParameters.__wrap(ret);
+    }
+    /**
+     * Evaluate the seven Helmert parameters at a decimal year.
+     * @param {number} epoch_year
+     * @returns {HelmertParameters}
+     */
+    parametersAt(epoch_year) {
+        const ret = wasm.helmerttransform_parametersAt(this.__wbg_ptr, epoch_year);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return HelmertParameters.__wrap(ret[0]);
+    }
+    /**
+     * Published table or memo that supplied this entry.
+     * @returns {string}
+     */
+    get provenance() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.helmerttransform_provenance(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Linear rates of the seven Helmert parameters.
+     * @returns {HelmertRates}
+     */
+    get rates() {
+        const ret = wasm.helmerttransform_rates(this.__wbg_ptr);
+        return HelmertRates.__wrap(ret);
+    }
+    /**
+     * Parameter reference epoch, expressed as a decimal year.
+     * @returns {number}
+     */
+    get referenceEpochYear() {
+        const ret = wasm.helmerttransform_referenceEpochYear(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Published target frame for the forward transform.
+     * @returns {TerrestrialFrame}
+     */
+    get to() {
+        const ret = wasm.helmerttransform_to(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) HelmertTransform.prototype[Symbol.dispose] = HelmertTransform.prototype.free;
+
 /**
  * A point in time, tagged UTC, with the precise time scales resolved.
  *
@@ -8404,7 +8767,7 @@ export class ObsHeader {
      */
     get timeOfFirstObsScale() {
         const ret = wasm.obsheader_timeOfFirstObsScale(this.__wbg_ptr);
-        return ret === 9 ? undefined : ret;
+        return ret === 11 ? undefined : ret;
     }
     /**
      * RINEX version, for example `3.05`.
@@ -12547,15 +12910,21 @@ export class RinexClock {
      * @returns {string}
      */
     toRinexString() {
-        let deferred1_0;
-        let deferred1_1;
+        let deferred2_0;
+        let deferred2_1;
         try {
             const ret = wasm.rinexclock_toRinexString(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
 }
@@ -15812,21 +16181,721 @@ export class SunMoon {
 if (Symbol.dispose) SunMoon.prototype[Symbol.dispose] = SunMoon.prototype.free;
 
 /**
- * Terrain datum conversion and optional geoid-grid loading error variants.
- * @enum {0 | 1 | 2 | 3}
+ * A parsed CCSDS Tracking Data Message.
  */
-export const TerrainDatumError = Object.freeze({
-    /**
-     * Terrain lookup failed before datum conversion.
-     */
-    Terrain: 0, "0": "Terrain",
-    /**
-     * A geoid grid could not be parsed.
-     */
-    Geoid: 1, "1": "Geoid",
-    /**
-     * Reading a geoid grid failed for a reason other than absence.
-     */
+export class Tdm {
+    static __wrap(ptr) {
+        const obj = Object.create(Tdm.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdm_free(ptr, 0);
+    }
+    /**
+     * Header comments in parse order.
+     * @returns {string[]}
+     */
+    get comments() {
+        const ret = wasm.tdm_comments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Optional `CREATION_DATE` header value.
+     * @returns {string | undefined}
+     */
+    get creationDate() {
+        const ret = wasm.tdm_creationDate(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Header fields not part of the common modeled header.
+     * @returns {TdmField[]}
+     */
+    get headerFields() {
+        const ret = wasm.tdm_headerFields(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Optional `MESSAGE_ID` header value.
+     * @returns {string | undefined}
+     */
+    get messageId() {
+        const ret = wasm.tdm_messageId(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Optional `ORIGINATOR` header value.
+     * @returns {string | undefined}
+     */
+    get originator() {
+        const ret = wasm.tdm_originator(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Number of segments in the message.
+     * @returns {number}
+     */
+    get segmentCount() {
+        const ret = wasm.tdm_segmentCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Metadata/data segments in message order.
+     * @returns {TdmSegment[]}
+     */
+    get segments() {
+        const ret = wasm.tdm_segments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Encode this TDM as canonical CCSDS KVN text.
+     * @returns {string}
+     */
+    toKvnString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.tdm_toKvnString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * The `CCSDS_TDM_VERS` header value.
+     * @returns {string}
+     */
+    get version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdm_version(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Tdm.prototype[Symbol.dispose] = Tdm.prototype.free;
+
+/**
+ * One time-tagged TDM tracking data record.
+ */
+export class TdmDataRecord {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmDataRecord.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmDataRecordFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmDataRecordFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmdatarecord_free(ptr, 0);
+    }
+    /**
+     * Raw epoch string.
+     * @returns {string}
+     */
+    get epoch() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmdatarecord_epoch(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Original data keyword.
+     * @returns {string}
+     */
+    get keyword() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmdatarecord_keyword(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Observable family label such as `"range"` or `"receiveFreq"`.
+     * @returns {string}
+     */
+    get observableKind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmdatarecord_observableKind(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Participant suffix for frequency records, or `undefined`.
+     * @returns {number | undefined}
+     */
+    get observableParticipant() {
+        const ret = wasm.tdmdatarecord_observableParticipant(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+    /**
+     * Original name for a table-defined keyword modeled as `other`.
+     * @returns {string | undefined}
+     */
+    get otherObservable() {
+        const ret = wasm.tdmdatarecord_otherObservable(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Numeric value plus exact decimal token.
+     * @returns {TdmScalar}
+     */
+    get scalar() {
+        const ret = wasm.tdmdatarecord_scalar(this.__wbg_ptr);
+        return TdmScalar.__wrap(ret);
+    }
+    /**
+     * Canonical unit label assigned by CCSDS 503.0-B-2.
+     * @returns {string}
+     */
+    get unit() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmdatarecord_unit(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Parsed numeric observable value.
+     * @returns {number}
+     */
+    get value() {
+        const ret = wasm.tdmdatarecord_value(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Exact decimal token used for KVN encoding.
+     * @returns {string}
+     */
+    get valueText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmdatarecord_valueText(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) TdmDataRecord.prototype[Symbol.dispose] = TdmDataRecord.prototype.free;
+
+/**
+ * A TDM data block.
+ */
+export class TdmDataSection {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmDataSection.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmDataSectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmDataSectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmdatasection_free(ptr, 0);
+    }
+    /**
+     * Data-section comments in parse order.
+     * @returns {string[]}
+     */
+    get comments() {
+        const ret = wasm.tdmdatasection_comments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Data records in parse order.
+     * @returns {TdmDataRecord[]}
+     */
+    get records() {
+        const ret = wasm.tdmdatasection_records(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TdmDataSection.prototype[Symbol.dispose] = TdmDataSection.prototype.free;
+
+/**
+ * A KVN key/value field preserved in parse order.
+ */
+export class TdmField {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmField.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmFieldFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmfield_free(ptr, 0);
+    }
+    /**
+     * The KVN keyword.
+     * @returns {string}
+     */
+    get key() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmfield_key(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The trimmed KVN value.
+     * @returns {string}
+     */
+    get value() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmfield_value(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) TdmField.prototype[Symbol.dispose] = TdmField.prototype.free;
+
+/**
+ * Metadata extracted from a TDM `META_START` / `META_STOP` block.
+ */
+export class TdmMetadata {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmMetadata.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmMetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmMetadataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmmetadata_free(ptr, 0);
+    }
+    /**
+     * Metadata comments in parse order.
+     * @returns {string[]}
+     */
+    get comments() {
+        const ret = wasm.tdmmetadata_comments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Raw metadata fields in parse order.
+     * @returns {TdmField[]}
+     */
+    get fields() {
+        const ret = wasm.tdmmetadata_fields(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Return the last metadata value for `key`, or `undefined`.
+     * @param {string} key
+     * @returns {string | undefined}
+     */
+    getLast(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tdmmetadata_getLast(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * Optional `MODE` value.
+     * @returns {string | undefined}
+     */
+    get mode() {
+        const ret = wasm.tdmmetadata_mode(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Parsed `PARTICIPANT_n` entries.
+     * @returns {TdmParticipant[]}
+     */
+    get participants() {
+        const ret = wasm.tdmmetadata_participants(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Parsed `PATH`, `PATH_1`, and `PATH_2` entries.
+     * @returns {TdmPath[]}
+     */
+    get paths() {
+        const ret = wasm.tdmmetadata_paths(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Range unit label used by `RANGE` records.
+     * @returns {string}
+     */
+    get rangeUnits() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmmetadata_rangeUnits(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Optional `TIME_SYSTEM` value.
+     * @returns {string | undefined}
+     */
+    get timeSystem() {
+        const ret = wasm.tdmmetadata_timeSystem(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Optional `TIMETAG_REF` value.
+     * @returns {string | undefined}
+     */
+    get timetagRef() {
+        const ret = wasm.tdmmetadata_timetagRef(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) TdmMetadata.prototype[Symbol.dispose] = TdmMetadata.prototype.free;
+
+/**
+ * One named TDM tracking participant.
+ */
+export class TdmParticipant {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmParticipant.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmParticipantFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmParticipantFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmparticipant_free(ptr, 0);
+    }
+    /**
+     * Numeric suffix from `PARTICIPANT_n`.
+     * @returns {number}
+     */
+    get index() {
+        const ret = wasm.tdmparticipant_index(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Participant name.
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmparticipant_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) TdmParticipant.prototype[Symbol.dispose] = TdmParticipant.prototype.free;
+
+/**
+ * A parsed TDM signal path from `PATH`, `PATH_1`, or `PATH_2`.
+ */
+export class TdmPath {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmPath.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmPathFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmPathFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmpath_free(ptr, 0);
+    }
+    /**
+     * Path suffix for `PATH_n`, or `undefined` for unindexed `PATH`.
+     * @returns {number | undefined}
+     */
+    get index() {
+        const ret = wasm.tdmpath_index(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+    /**
+     * Original path keyword.
+     * @returns {string}
+     */
+    get key() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmpath_key(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Participant indices listed in path order.
+     * @returns {Uint8Array}
+     */
+    get participants() {
+        const ret = wasm.tdmpath_participants(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) TdmPath.prototype[Symbol.dispose] = TdmPath.prototype.free;
+
+/**
+ * A numeric TDM record value plus its exact decimal token.
+ */
+export class TdmScalar {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmScalar.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmScalarFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmScalarFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmscalar_free(ptr, 0);
+    }
+    /**
+     * Exact decimal or scientific-notation token read from the message.
+     * @returns {string}
+     */
+    get text() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tdmscalar_text(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Parsed finite `f64` value.
+     * @returns {number}
+     */
+    get value() {
+        const ret = wasm.tdmscalar_value(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) TdmScalar.prototype[Symbol.dispose] = TdmScalar.prototype.free;
+
+/**
+ * One TDM segment, consisting of metadata and data blocks.
+ */
+export class TdmSegment {
+    static __wrap(ptr) {
+        const obj = Object.create(TdmSegment.prototype);
+        obj.__wbg_ptr = ptr;
+        TdmSegmentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TdmSegmentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmsegment_free(ptr, 0);
+    }
+    /**
+     * Tracking data records for this segment.
+     * @returns {TdmDataSection}
+     */
+    get data() {
+        const ret = wasm.tdmsegment_data(this.__wbg_ptr);
+        return TdmDataSection.__wrap(ret);
+    }
+    /**
+     * Metadata describing this segment's records.
+     * @returns {TdmMetadata}
+     */
+    get metadata() {
+        const ret = wasm.tdmsegment_metadata(this.__wbg_ptr);
+        return TdmMetadata.__wrap(ret);
+    }
+}
+if (Symbol.dispose) TdmSegment.prototype[Symbol.dispose] = TdmSegment.prototype.free;
+
+/**
+ * Terrain datum conversion and optional geoid-grid loading error variants.
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const TerrainDatumError = Object.freeze({
+    /**
+     * Terrain lookup failed before datum conversion.
+     */
+    Terrain: 0, "0": "Terrain",
+    /**
+     * A geoid grid could not be parsed.
+     */
+    Geoid: 1, "1": "Geoid",
+    /**
+     * Reading a geoid grid failed for a reason other than absence.
+     */
     Io: 2, "2": "Io",
     /**
      * The EGM96 15-arcminute `WW15MGH.DAC` grid was requested but is absent.
@@ -16044,9 +17113,32 @@ export class TerrainStoreTileIndex {
 }
 if (Symbol.dispose) TerrainStoreTileIndex.prototype[Symbol.dispose] = TerrainStoreTileIndex.prototype.free;
 
+/**
+ * A supported terrestrial reference-frame realization.
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const TerrestrialFrame = Object.freeze({
+    /**
+     * International Terrestrial Reference Frame 2020.
+     */
+    Itrf2020: 0, "0": "Itrf2020",
+    /**
+     * International Terrestrial Reference Frame 2014.
+     */
+    Itrf2014: 1, "1": "Itrf2014",
+    /**
+     * International Terrestrial Reference Frame 2008.
+     */
+    Itrf2008: 2, "2": "Itrf2008",
+    /**
+     * European Terrestrial Reference Frame 2020.
+     */
+    Etrf2020: 3, "3": "Etrf2020",
+});
+
 /**
  * A named time scale. The JS value matches the variant order below.
- * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
  */
 export const TimeScale = Object.freeze({
     /**
@@ -16085,6 +17177,14 @@ export const TimeScale = Object.freeze({
      * QZSS system time (steered to GPST).
      */
     Qzsst: 8, "8": "Qzsst",
+    /**
+     * Geocentric Coordinate Time.
+     */
+    Tcg: 9, "9": "Tcg",
+    /**
+     * Barycentric Coordinate Time.
+     */
+    Tcb: 10, "10": "Tcb",
 });
 
 /**
@@ -16348,6 +17448,27 @@ export class Tle {
         }
         return TlePropagation.__wrap(ret[0]);
     }
+    /**
+     * Propagate over unix-microsecond epochs with an opt-in decay latch.
+     *
+     * The returned TEME arrays match [`propagate`] until the first decay-like
+     * SGP4 failure. At that point the core latch records the failing epoch and
+     * this method throws. Later calls using the same latch at that epoch or a
+     * later one also throw, while raw [`propagate`] remains stateless.
+     * @param {BigInt64Array} epochs_unix_us
+     * @param {DecayLatch} latch
+     * @returns {TlePropagation}
+     */
+    propagateWithDecayLatch(epochs_unix_us, latch) {
+        const ptr0 = passArray64ToWasm0(epochs_unix_us, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(latch, DecayLatch);
+        const ret = wasm.tle_propagateWithDecayLatch(this.__wbg_ptr, ptr0, len0, latch.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TlePropagation.__wrap(ret[0]);
+    }
     /**
      * Right ascension of the ascending node, degrees.
      * @returns {number}
@@ -18703,6 +19824,24 @@ export function findTcaConjunctions(primary_line1, primary_line2, secondary_line
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Fit every satellite declared in a parsed ECEF SP3 precise product.
+ *
+ * The residual ledger is computed against the original Earth-fixed SP3
+ * observations by the core fit path.
+ * @param {Sp3} sp3
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitAllSp3EcefPreciseOrbits(sp3, options) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.fitAllSp3EcefPreciseOrbits(sp3.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fit a piecewise reduced-orbit model: tile `[t0, t1]` into segments of
  * `segmentSeconds` and fit each independently.
@@ -18872,6 +20011,47 @@ export function fitReducedOrbitTle(tle, options) {
     return ReducedOrbitSourceFit.__wrap(ret[0]);
 }
 
+/**
+ * Fit one satellite orbit from a parsed ECEF SP3 precise product.
+ *
+ * `satellite` is an IGS token such as `"G01"`. SP3 position and optional
+ * velocity records are transformed from Earth-fixed coordinates through the
+ * core `TdbEarthOrientationProvider` before fitting.
+ * @param {Sp3} sp3
+ * @param {string} satellite
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitSp3EcefPreciseOrbit(sp3, satellite, options) {
+    _assertClass(sp3, Sp3);
+    const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fitSp3EcefPreciseOrbit(sp3.__wbg_ptr, ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Fit selected satellite orbits from a parsed ECEF SP3 precise product.
+ *
+ * `satellites` is a string array of IGS tokens such as `["G01", "G02"]`.
+ * The Earth-fixed to inertial conversion is handled by the core provider.
+ * @param {Sp3} sp3
+ * @param {any} satellites
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitSp3EcefPreciseOrbits(sp3, satellites, options) {
+    _assertClass(sp3, Sp3);
+    const ret = wasm.fitSp3EcefPreciseOrbits(sp3.__wbg_ptr, satellites, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fit one satellite orbit from a parsed SP3 precise product.
  *
@@ -18996,6 +20176,105 @@ export function forceTwoBodyAcceleration(position_km, velocity_km_s) {
     return v3;
 }
 
+/**
+ * Return the built-in terrestrial frame catalog entries.
+ * @returns {HelmertTransform[]}
+ */
+export function frameCatalog() {
+    const ret = wasm.frameCatalog();
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Return the published catalog entry for the requested forward direction.
+ * @param {TerrestrialFrame} from
+ * @param {TerrestrialFrame} to
+ * @returns {HelmertTransform | undefined}
+ */
+export function frameCatalogEntry(from, to) {
+    const ret = wasm.frameCatalogEntry(from, to);
+    return ret === 0 ? undefined : HelmertTransform.__wrap(ret);
+}
+
+/**
+ * Propagate a station position from one decimal year to another.
+ *
+ * `positionM` and `velocityMPerYear` are length-3 arrays in metres and metres
+ * per year. Returns a length-3 array in metres. Delegates to
+ * `sidereon_core::frame_catalog::propagate_position`.
+ * @param {Float64Array} position_m
+ * @param {Float64Array} velocity_m_per_year
+ * @param {number} from_epoch_year
+ * @param {number} to_epoch_year
+ * @returns {Float64Array}
+ */
+export function frameCatalogPropagatePosition(position_m, velocity_m_per_year, from_epoch_year, to_epoch_year) {
+    const ptr0 = passArrayF64ToWasm0(position_m, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_m_per_year, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.frameCatalogPropagatePosition(ptr0, len0, ptr1, len1, from_epoch_year, to_epoch_year);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Transform a Cartesian station position and optional velocity between frames.
+ *
+ * `positionM` is a length-3 metre array. `velocityMPerYear` may be `undefined`
+ * or a length-3 metres-per-year array. Returns a plain object with
+ * `positionM` and `velocityMPerYear` (`null` when no velocity was supplied).
+ * @param {Float64Array} position_m
+ * @param {Float64Array | null | undefined} velocity_m_per_year
+ * @param {TerrestrialFrame} from
+ * @param {TerrestrialFrame} to
+ * @param {number} epoch_year
+ * @returns {any}
+ */
+export function frameCatalogTransform(position_m, velocity_m_per_year, from, to, epoch_year) {
+    const ptr0 = passArrayF64ToWasm0(position_m, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(velocity_m_per_year) ? 0 : passArrayF64ToWasm0(velocity_m_per_year, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.frameCatalogTransform(ptr0, len0, ptr1, len1, from, to, epoch_year);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Propagate a station to a transform epoch, then transform it between frames.
+ *
+ * `positionEpochYear` is the epoch of the input coordinates. The transform is
+ * evaluated at `transformEpochYear`. Returns a plain object with `positionM`
+ * and `velocityMPerYear`.
+ * @param {Float64Array} position_m
+ * @param {Float64Array} velocity_m_per_year
+ * @param {number} position_epoch_year
+ * @param {TerrestrialFrame} from
+ * @param {TerrestrialFrame} to
+ * @param {number} transform_epoch_year
+ * @returns {any}
+ */
+export function frameCatalogTransformFromEpoch(position_m, velocity_m_per_year, position_epoch_year, from, to, transform_epoch_year) {
+    const ptr0 = passArrayF64ToWasm0(position_m, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(velocity_m_per_year, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.frameCatalogTransformFromEpoch(ptr0, len0, ptr1, len1, position_epoch_year, from, to, transform_epoch_year);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Build constellation identity records from a CelesTrak OMM JSON-array text.
  *
@@ -19136,6 +20415,67 @@ export function gcrsToItrs(position_km, epochs_unix_us, skyfield_compat) {
     return v3;
 }
 
+/**
+ * Solve the WGS84 direct geodesic problem.
+ *
+ * Inputs are point 1 latitude, longitude, forward azimuth, and geodesic
+ * distance. Angles are degrees and `distanceM` is metres. Returns
+ * `{ lat2Deg, lon2Deg, finalAzimuthDeg }`. Delegates to
+ * `sidereon_core::geodesic::geodesic_direct`.
+ * @param {number} lat1_deg
+ * @param {number} lon1_deg
+ * @param {number} initial_azimuth_deg
+ * @param {number} distance_m
+ * @returns {any}
+ */
+export function geodesicDirect(lat1_deg, lon1_deg, initial_azimuth_deg, distance_m) {
+    const ret = wasm.geodesicDirect(lat1_deg, lon1_deg, initial_azimuth_deg, distance_m);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Stable string label for a [`GeodesicError`] enum value.
+ * @param {GeodesicError} error
+ * @returns {string}
+ */
+export function geodesicErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.geodesicErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Solve the WGS84 inverse geodesic problem.
+ *
+ * Inputs are point 1 latitude and longitude followed by point 2 latitude and
+ * longitude, all in degrees. Longitudes may be outside `[-180, 180]`. Returns
+ * `{ distanceM, initialAzimuthDeg, finalAzimuthDeg }`, with distance in metres
+ * and azimuths in degrees. Delegates to
+ * `sidereon_core::geodesic::geodesic_inverse`.
+ * @param {number} lat1_deg
+ * @param {number} lon1_deg
+ * @param {number} lat2_deg
+ * @param {number} lon2_deg
+ * @returns {any}
+ */
+export function geodesicInverse(lat1_deg, lon1_deg, lat2_deg, lon2_deg) {
+    const ret = wasm.geodesicInverse(lat1_deg, lon1_deg, lat2_deg, lon2_deg);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Convert a batch of geodetic coordinates to ITRS (ECEF).
  *
@@ -21744,6 +23084,21 @@ export function parseSpaceWeatherTxt(text) {
     return SpaceWeatherTable.__wrap(ret[0]);
 }
 
+/**
+ * Parse a CCSDS Tracking Data Message in KVN form.
+ * @param {string} text
+ * @returns {Tdm}
+ */
+export function parseTdmKvn(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseTdmKvn(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Tdm.__wrap(ret[0]);
+}
+
 /**
  * Parse a multi-record TLE file (CelesTrak / Space-Track style) into named,
  * initialized [`Tle`] instances. Handles bare 2-line sets, 3-line name+line1+line2
@@ -22896,6 +24251,32 @@ export function shadowFraction(satellite_position_km, sun_position_km) {
     return v3;
 }
 
+/**
+ * Shadow fraction in `[0, 1]` for position batches with an explicit Earth
+ * shadow model.
+ *
+ * `satellitePositionKm` and `sunPositionKm` are flat row-major `(n, 3)`
+ * `Float64Array`s. `EarthShadowModel.Spherical` is bit-identical to
+ * [`shadowFraction`].
+ * @param {Float64Array} satellite_position_km
+ * @param {Float64Array} sun_position_km
+ * @param {EarthShadowModel} model
+ * @returns {Float64Array}
+ */
+export function shadowFractionWithModel(satellite_position_km, sun_position_km, model) {
+    const ptr0 = passArrayF64ToWasm0(satellite_position_km, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(sun_position_km, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.shadowFractionWithModel(ptr0, len0, ptr1, len1, model);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Shapiro-Wilk normality test on a residual set.
  *
@@ -23749,6 +25130,24 @@ export function terrainStoreChecksum64(bytes) {
     return BigInt.asUintN(64, ret);
 }
 
+/**
+ * Stable string label for a [`TerrestrialFrame`] enum value.
+ * @param {TerrestrialFrame} frame
+ * @returns {string}
+ */
+export function terrestrialFrameLabel(frame) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.terrestrialFrameLabel(frame);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Time deviation for explicit averaging factors.
  *
@@ -24158,7 +25557,7 @@ export function writeDtedTreeToMmapStore(root, out_path) {
  *
  * `alpha` is the two-sided false-alarm probability. `power` is detection power,
  * so the core missed-detection probability is `1 - power`. The returned object
- * contains `delta0` and `lambda0 = delta0 * delta0`.
+ * contains the core-provided `delta0` and `lambda0` values.
  * @param {number} alpha
  * @param {number} power
  * @returns {any}
@@ -24340,6 +25739,10 @@ function __wbg_get_imports() {
             const ret = GroundTrack.__wrap(arg0);
             return ret;
         },
+        __wbg_helmerttransform_new: function(arg0) {
+            const ret = HelmertTransform.__wrap(arg0);
+            return ret;
+        },
         __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
             let result;
             try {
@@ -24550,6 +25953,26 @@ function __wbg_get_imports() {
             const ret = SpkSegment.__wrap(arg0);
             return ret;
         },
+        __wbg_tdmdatarecord_new: function(arg0) {
+            const ret = TdmDataRecord.__wrap(arg0);
+            return ret;
+        },
+        __wbg_tdmfield_new: function(arg0) {
+            const ret = TdmField.__wrap(arg0);
+            return ret;
+        },
+        __wbg_tdmparticipant_new: function(arg0) {
+            const ret = TdmParticipant.__wrap(arg0);
+            return ret;
+        },
+        __wbg_tdmpath_new: function(arg0) {
+            const ret = TdmPath.__wrap(arg0);
+            return ret;
+        },
+        __wbg_tdmsegment_new: function(arg0) {
+            const ret = TdmSegment.__wrap(arg0);
+            return ret;
+        },
         __wbg_terrainstoretileindex_new: function(arg0) {
             const ret = TerrainStoreTileIndex.__wrap(arg0);
             return ret;
@@ -24695,6 +26118,9 @@ const CovarianceTransportResultFinalization = (typeof FinalizationRegistry === '
 const CoverageGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_coveragegrid_free(ptr, 1));
+const DecayLatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_decaylatch_free(ptr, 1));
 const DegradationParamsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_degradationparams_free(ptr, 1));
@@ -24782,6 +26208,15 @@ const GroundStationFinalization = (typeof FinalizationRegistry === 'undefined')
 const GroundTrackFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_groundtrack_free(ptr, 1));
+const HelmertParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_helmertparameters_free(ptr, 1));
+const HelmertRatesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_helmertrates_free(ptr, 1));
+const HelmertTransformFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_helmerttransform_free(ptr, 1));
 const InstantFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_instant_free(ptr, 1));
@@ -25094,6 +26529,33 @@ const SsrCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefin
 const SunMoonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sunmoon_free(ptr, 1));
+const TdmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdm_free(ptr, 1));
+const TdmDataRecordFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmdatarecord_free(ptr, 1));
+const TdmDataSectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmdatasection_free(ptr, 1));
+const TdmFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmfield_free(ptr, 1));
+const TdmMetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmmetadata_free(ptr, 1));
+const TdmParticipantFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmparticipant_free(ptr, 1));
+const TdmPathFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmpath_free(ptr, 1));
+const TdmScalarFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmscalar_free(ptr, 1));
+const TdmSegmentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmsegment_free(ptr, 1));
 const TerrainGeoidModelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_terraingeoidmodel_free(ptr, 1));