@saber-usa/node-common 1.7.18-alpha.1 → 1.7.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber-usa/node-common",
-  "version": "1.7.18-alpha.1",
+  "version": "1.7.19",
   "description": "Common node functions for Saber",
   "main": "src/index.js",
   "type": "module",
@@ -29,7 +29,7 @@
     "mathjs": "^15.2.0",
     "pious-squid": "^2.3.0",
     "plotly": "^1.0.6",
-    "satellite.js": "^7.0.0",
+    "satellite.js": "^7.0.1",
     "solar-calculator": "^0.3.0",
     "three": "^0.184",
     "winston": "3.19.0"

package/src/wasmProp/index.js

@@ -1,10 +1,10 @@
-// Barrel for all WASM-backed bulk propagation exports. Kept behind a
-// single entry point so the rest of the codebase (and external consumers
-// via `@saber-usa/node-common`) can discover the bulk API without having
-// to reach into per-feature files.
-//
-// See `docs/BULK_PROPAGATION.md` for the design rationale, lifecycle, and
-// the measured performance characteristics.
-export * from "./runtime.js";
-export * from "./primitives.js";
-export * from "./wasmAstro.js";
+// Barrel for all WASM-backed bulk propagation exports. Kept behind a
+// single entry point so the rest of the codebase (and external consumers
+// via `@saber-usa/node-common`) can discover the bulk API without having
+// to reach into per-feature files.
+//
+// See `docs/BULK_PROPAGATION.md` for the design rationale, lifecycle, and
+// the measured performance characteristics.
+export * from "./runtime.js";
+export * from "./primitives.js";
+export * from "./wasmAstro.js";

package/src/wasmProp/primitives.js

@@ -1,295 +1,295 @@
-import {
-    twoline2satrec,
-    EciBaseCalculator,
-    GmstCalculator,
-    EcfPositionCalculator,
-    GeodeticPositionCalculator,
-    LookAnglesCalculator,
-} from "satellite.js";
-import {getBulkRuntime, getOrCreateBulkPropagator} from "./runtime.js";
-import {RAD2DEG} from "../constants.js";
-
-// ----------------------------------------------------------------------------
-// WASM-backed bulk primitives
-//
-// Sibling functions to `prop` / `propGeodetic` / the manual LookAngles chain
-// that live in `../astro.js`. The originals stay synchronous; these are
-// async because the per-thread `BulkPropagator` runtime is async-bootstrapped
-// (see `docs/BULK_PROPAGATION.md`).
-//
-// Time-grid semantics are matched exactly to the JS-path siblings to keep
-// parity tests trivial:
-//   - `propBulk`         mirrors `prop`         -> half-open [start, end)
-//   - `propGeodeticBulk` mirrors `propGeodetic` -> closed    [start, end]
-//
-// Return shapes mirror the JS-path siblings element-wise so callers can swap
-// transparently. `meanElements` is intentionally absent from `propBulk`
-// records: the WASM `EciBaseCalculator` exposes only position/velocity/error,
-// it does not surface SGP4 mean elements. Callers that need them must either
-// stay on `prop` or recompute osculating elements from p/v.
-// ----------------------------------------------------------------------------
-
-/**
- * Builds the closed list of evaluation timestamps for a half-open or closed
- * interval, matching the loop semantics of `prop` / `propGeodetic`.
- *
- * @param {number} start
- * @param {number} end
- * @param {number} stepMs
- * @param {boolean} inclusive when true, end is included (propGeodetic).
- * @return {number[]}
- */
-const buildTimeGrid = (start, end, stepMs, inclusive) => {
-    const grid = [];
-    if (inclusive) {
-        for (let t = start; t <= end; t = t + stepMs) {grid.push(t);}
-    } else {
-        for (let t = start; t < end; t = t + stepMs) {grid.push(t);}
-    }
-    return grid;
-};
-
-/**
- * Bulk-converts an array of `{Line1, Line2}` elsets into satrecs, returning
- * `null` if any single elset fails to convert. Mirrors the silent-skip
- * behavior of `prop` (which returns `[]` on the first invalid pv).
- *
- * @param {Array<{Line1: string, Line2: string}>} elsets
- * @return {Array|null}
- */
-const elsetsToSatrecs = (elsets) => {
-    const satrecs = elsets.map((e) => twoline2satrec(e.Line1, e.Line2));
-    return satrecs;
-};
-
-/**
- * WASM-backed sibling of `prop`. Computes ECI position and velocity for
- * `elsets.length` satellites at every step in the half-open interval
- * `[start, end)` with step `stepMs`.
- *
- * Returns `Array<Array<{p, v, t}>>` indexed `[satIdx][dateIdx]`. Each inner
- * array matches the shape returned by `prop` minus the `meanElements` field
- * (see module-level note). If the WASM SGP4 produces a non-zero error code
- * for any (sat, date) pair, that satellite's entire ephemeris is returned as
- * `[]` — same all-or-nothing semantic as `prop` on `propTo` failure.
- *
- * @param {Array<{Line1: string, Line2: string}>} elsets
- * @param {number} start UNIX milliseconds
- * @param {number} end UNIX milliseconds (exclusive)
- * @param {number} stepMs default 1000
- * @return {Promise<Array<Array<{p: object, v: object, t: number}>>>}
- */
-const propBulk = async (elsets, start, end, stepMs = 1000) => {
-    const grid = buildTimeGrid(start, end, stepMs, false);
-    if (elsets.length === 0 || grid.length === 0) {
-        return elsets.map(() => []);
-    }
-    const satrecs = elsetsToSatrecs(elsets);
-    const dates = grid.map((t) => new Date(t));
-
-    const runtime = await getBulkRuntime();
-    const propagator = getOrCreateBulkPropagator({
-        runtime,
-        key: "eci",
-        makeCalculators: () => [new EciBaseCalculator()],
-        satRecsCount: satrecs.length,
-        datesCount: dates.length,
-    });
-    propagator.setSatRecs(satrecs);
-    propagator.setDates(dates);
-    propagator.run();
-
-    const {eci} = propagator.getRawOutput();
-    // raw layout: [sat0 date0 (x,y,z), sat0 date1 (x,y,z), ..., sat1 date0, ...]
-    // error layout: [sat0 date0, sat0 date1, ..., sat1 date0, ...]
-    const out = new Array(satrecs.length);
-    const m = dates.length;
-    for (let s = 0; s < satrecs.length; s++) {
-        const ephem = new Array(m);
-        let satFailed = false;
-        for (let d = 0; d < m; d++) {
-            const errIdx = s * m + d;
-            if (eci.error[errIdx] !== 0) {
-                satFailed = true;
-                break;
-            }
-            const vec = (s * m + d) * 3;
-            ephem[d] = {
-                p: {
-                    x: eci.position[vec],
-                    y: eci.position[vec + 1],
-                    z: eci.position[vec + 2],
-                },
-                v: {
-                    x: eci.velocity[vec],
-                    y: eci.velocity[vec + 1],
-                    z: eci.velocity[vec + 2],
-                },
-                t: grid[d],
-            };
-        }
-        out[s] = satFailed ? [] : ephem;
-    }
-    return out;
-};
-
-/**
- * WASM-backed sibling of `propGeodetic`. Computes geodetic
- * (lat, lon, t) for every satellite at every step in the closed interval
- * `[start, end]`.
- *
- * Lat/Lon are returned in **degrees** to match `propGeodetic`. Returns
- * `Array<Array<{lat, lon, t}>>` indexed `[satIdx][dateIdx]`. On any SGP4
- * error for a satellite the whole ephemeris for that satellite is `[]`,
- * matching `propGeodetic`'s short-circuit behavior.
- *
- * @param {Array<{Line1: string, Line2: string}>} elsets
- * @param {number} start UNIX milliseconds
- * @param {number} end UNIX milliseconds (inclusive)
- * @param {number} stepMs default 60000
- * @return {Promise<Array<Array<{lat: number, lon: number, t: number}>>>}
- */
-const propGeodeticBulk = async (elsets, start, end, stepMs = 60000) => {
-    const grid = buildTimeGrid(start, end, stepMs, true);
-    if (elsets.length === 0 || grid.length === 0) {
-        return elsets.map(() => []);
-    }
-    const satrecs = elsetsToSatrecs(elsets);
-    const dates = grid.map((t) => new Date(t));
-
-    const runtime = await getBulkRuntime();
-    const propagator = getOrCreateBulkPropagator({
-        runtime,
-        key: "eci+gmst+geo",
-        makeCalculators: () => [
-            new EciBaseCalculator(),
-            new GmstCalculator(),
-            new GeodeticPositionCalculator(),
-        ],
-        satRecsCount: satrecs.length,
-        datesCount: dates.length,
-    });
-    propagator.setSatRecs(satrecs);
-    propagator.setDates(dates);
-    propagator.run();
-
-    const {eci, geodeticPosition} = propagator.getRawOutput();
-    // KNOWN satellite.js@7.0.0 BUG / docs error: the
-    // `GeodeticPositionCalculator` raw layout is documented as
-    // `[lat, lon, height, ...]`, and `getFormattedOutput()` exposes fields
-    // `{latitude: raw[0], longitude: raw[1], height: raw[2]}` — but the
-    // physical values are SWAPPED. Empirically, against the canonical JS
-    // `eciToGeodetic` path:
-    //   raw[3*k + 0] -> physical LONGITUDE (in radians)
-    //   raw[3*k + 1] -> physical LATITUDE  (in radians)
-    //   raw[3*k + 2] -> height (km)
-    // We map raw -> {lat, lon} accordingly so `propGeodeticBulk` is exactly
-    // value-equivalent to `propGeodetic`. If a future satellite.js release
-    // fixes this upstream, swap the indices back here.
-    const out = new Array(satrecs.length);
-    const m = dates.length;
-    for (let s = 0; s < satrecs.length; s++) {
-        const positions = new Array(m);
-        let satFailed = false;
-        for (let d = 0; d < m; d++) {
-            const errIdx = s * m + d;
-            if (eci.error[errIdx] !== 0) {
-                satFailed = true;
-                break;
-            }
-            const vec = (s * m + d) * 3;
-            positions[d] = {
-                lat: geodeticPosition[vec + 1] * RAD2DEG,
-                lon: geodeticPosition[vec] * RAD2DEG,
-                t: grid[d],
-            };
-        }
-        out[s] = satFailed ? [] : positions;
-    }
-    return out;
-};
-
-/**
- * WASM-backed bulk look-angles primitive. Computes (azimuth, elevation,
- * rangeSat) for every satellite at every supplied date relative to a single
- * observer (Geodetic location, **radians + km** as required by satellite.js
- * v7 — `{latitude, longitude, height}`).
- *
- * Unlike `propBulk` and `propGeodeticBulk` this primitive takes an explicit
- * `dates` array (rather than start/end/step) because look-angles consumers
- * typically already hold the date list (e.g. observation timestamps in
- * `GetResiduals`) and synthesizing a regular grid would re-impose JS-side
- * step math the WASM pipeline is meant to avoid.
- *
- * Returns `Array<Array<{azimuth, elevation, rangeSat, t}>>` indexed
- * `[satIdx][dateIdx]`, with angles in **radians** and `rangeSat` in km. On
- * any SGP4 error for a satellite that satellite's entire output is `[]`.
- *
- * @param {Array<{Line1: string, Line2: string}>} elsets
- * @param {Date[]|number[]} dates
- * @param {{latitude: number, longitude: number, height: number}} observerGd
- *   Observer position in radians (lat/lon) and km (height).
- * @return {Promise<Array<Array<{azimuth: number, elevation: number, rangeSat: number, t: number}>>>}
- */
-const propLookAnglesBulk = async (elsets, dates, observerGd) => {
-    if (elsets.length === 0 || dates.length === 0) {
-        return elsets.map(() => []);
-    }
-    const satrecs = elsetsToSatrecs(elsets);
-    const dateObjs = dates.map((d) => (d instanceof Date ? d : new Date(d)));
-    const ts = dateObjs.map((d) => d.getTime());
-
-    const runtime = await getBulkRuntime();
-    const propagator = getOrCreateBulkPropagator({
-        runtime,
-        key: "eci+gmst+ecf+lookAngles",
-        makeCalculators: () => [
-            new EciBaseCalculator(),
-            new GmstCalculator(),
-            new EcfPositionCalculator(),
-            new LookAnglesCalculator(),
-        ],
-        satRecsCount: satrecs.length,
-        datesCount: dateObjs.length,
-    });
-    propagator.setSatRecs(satrecs);
-    propagator.setDates(dateObjs);
-    propagator.run({lookAngles: {observer: observerGd}});
-
-    const {eci, lookAngles} = propagator.getRawOutput();
-    // lookAngles layout: [sat0 date0 (az, el, range), sat0 date1, ...]
-    const out = new Array(satrecs.length);
-    const m = dateObjs.length;
-    for (let s = 0; s < satrecs.length; s++) {
-        const samples = new Array(m);
-        let satFailed = false;
-        for (let d = 0; d < m; d++) {
-            const errIdx = s * m + d;
-            if (eci.error[errIdx] !== 0) {
-                satFailed = true;
-                break;
-            }
-            const vec = (s * m + d) * 3;
-            samples[d] = {
-                azimuth: lookAngles[vec],
-                elevation: lookAngles[vec + 1],
-                rangeSat: lookAngles[vec + 2],
-                t: ts[d],
-            };
-        }
-        out[s] = satFailed ? [] : samples;
-    }
-    return out;
-};
-
-export {
-    // `buildTimeGrid` is intentionally NOT exported: it is consumed only by
-    // `propBulk` / `propGeodeticBulk` inside this module. Keeping it private
-    // avoids polluting the public `@saber-usa/node-common` surface with a
-    // helper that exists purely to bridge the JS-path loop semantics to the
-    // WASM `setDates(Date[])` API.
-    elsetsToSatrecs, // used by `./wasmAstro.js#getGeoShadowZonesBulk`
-    propBulk,
-    propGeodeticBulk,
-    propLookAnglesBulk,
-};
+import {
+    twoline2satrec,
+    EciBaseCalculator,
+    GmstCalculator,
+    EcfPositionCalculator,
+    GeodeticPositionCalculator,
+    LookAnglesCalculator,
+} from "satellite.js";
+import {getBulkRuntime, getOrCreateBulkPropagator} from "./runtime.js";
+import {RAD2DEG} from "../constants.js";
+
+// ----------------------------------------------------------------------------
+// WASM-backed bulk primitives
+//
+// Sibling functions to `prop` / `propGeodetic` / the manual LookAngles chain
+// that live in `../astro.js`. The originals stay synchronous; these are
+// async because the per-thread `BulkPropagator` runtime is async-bootstrapped
+// (see `docs/BULK_PROPAGATION.md`).
+//
+// Time-grid semantics are matched exactly to the JS-path siblings to keep
+// parity tests trivial:
+//   - `propBulk`         mirrors `prop`         -> half-open [start, end)
+//   - `propGeodeticBulk` mirrors `propGeodetic` -> closed    [start, end]
+//
+// Return shapes mirror the JS-path siblings element-wise so callers can swap
+// transparently. `meanElements` is intentionally absent from `propBulk`
+// records: the WASM `EciBaseCalculator` exposes only position/velocity/error,
+// it does not surface SGP4 mean elements. Callers that need them must either
+// stay on `prop` or recompute osculating elements from p/v.
+// ----------------------------------------------------------------------------
+
+/**
+ * Builds the closed list of evaluation timestamps for a half-open or closed
+ * interval, matching the loop semantics of `prop` / `propGeodetic`.
+ *
+ * @param {number} start
+ * @param {number} end
+ * @param {number} stepMs
+ * @param {boolean} inclusive when true, end is included (propGeodetic).
+ * @return {number[]}
+ */
+const buildTimeGrid = (start, end, stepMs, inclusive) => {
+    const grid = [];
+    if (inclusive) {
+        for (let t = start; t <= end; t = t + stepMs) {grid.push(t);}
+    } else {
+        for (let t = start; t < end; t = t + stepMs) {grid.push(t);}
+    }
+    return grid;
+};
+
+/**
+ * Bulk-converts an array of `{Line1, Line2}` elsets into satrecs, returning
+ * `null` if any single elset fails to convert. Mirrors the silent-skip
+ * behavior of `prop` (which returns `[]` on the first invalid pv).
+ *
+ * @param {Array<{Line1: string, Line2: string}>} elsets
+ * @return {Array|null}
+ */
+const elsetsToSatrecs = (elsets) => {
+    const satrecs = elsets.map((e) => twoline2satrec(e.Line1, e.Line2));
+    return satrecs;
+};
+
+/**
+ * WASM-backed sibling of `prop`. Computes ECI position and velocity for
+ * `elsets.length` satellites at every step in the half-open interval
+ * `[start, end)` with step `stepMs`.
+ *
+ * Returns `Array<Array<{p, v, t}>>` indexed `[satIdx][dateIdx]`. Each inner
+ * array matches the shape returned by `prop` minus the `meanElements` field
+ * (see module-level note). If the WASM SGP4 produces a non-zero error code
+ * for any (sat, date) pair, that satellite's entire ephemeris is returned as
+ * `[]` — same all-or-nothing semantic as `prop` on `propTo` failure.
+ *
+ * @param {Array<{Line1: string, Line2: string}>} elsets
+ * @param {number} start UNIX milliseconds
+ * @param {number} end UNIX milliseconds (exclusive)
+ * @param {number} stepMs default 1000
+ * @return {Promise<Array<Array<{p: object, v: object, t: number}>>>}
+ */
+const propBulk = async (elsets, start, end, stepMs = 1000) => {
+    const grid = buildTimeGrid(start, end, stepMs, false);
+    if (elsets.length === 0 || grid.length === 0) {
+        return elsets.map(() => []);
+    }
+    const satrecs = elsetsToSatrecs(elsets);
+    const dates = grid.map((t) => new Date(t));
+
+    const runtime = await getBulkRuntime();
+    const propagator = getOrCreateBulkPropagator({
+        runtime,
+        key: "eci",
+        makeCalculators: () => [new EciBaseCalculator()],
+        satRecsCount: satrecs.length,
+        datesCount: dates.length,
+    });
+    propagator.setSatRecs(satrecs);
+    propagator.setDates(dates);
+    propagator.run();
+
+    const {eci} = propagator.getRawOutput();
+    // raw layout: [sat0 date0 (x,y,z), sat0 date1 (x,y,z), ..., sat1 date0, ...]
+    // error layout: [sat0 date0, sat0 date1, ..., sat1 date0, ...]
+    const out = new Array(satrecs.length);
+    const m = dates.length;
+    for (let s = 0; s < satrecs.length; s++) {
+        const ephem = new Array(m);
+        let satFailed = false;
+        for (let d = 0; d < m; d++) {
+            const errIdx = s * m + d;
+            if (eci.error[errIdx] !== 0) {
+                satFailed = true;
+                break;
+            }
+            const vec = (s * m + d) * 3;
+            ephem[d] = {
+                p: {
+                    x: eci.position[vec],
+                    y: eci.position[vec + 1],
+                    z: eci.position[vec + 2],
+                },
+                v: {
+                    x: eci.velocity[vec],
+                    y: eci.velocity[vec + 1],
+                    z: eci.velocity[vec + 2],
+                },
+                t: grid[d],
+            };
+        }
+        out[s] = satFailed ? [] : ephem;
+    }
+    return out;
+};
+
+/**
+ * WASM-backed sibling of `propGeodetic`. Computes geodetic
+ * (lat, lon, t) for every satellite at every step in the closed interval
+ * `[start, end]`.
+ *
+ * Lat/Lon are returned in **degrees** to match `propGeodetic`. Returns
+ * `Array<Array<{lat, lon, t}>>` indexed `[satIdx][dateIdx]`. On any SGP4
+ * error for a satellite the whole ephemeris for that satellite is `[]`,
+ * matching `propGeodetic`'s short-circuit behavior.
+ *
+ * @param {Array<{Line1: string, Line2: string}>} elsets
+ * @param {number} start UNIX milliseconds
+ * @param {number} end UNIX milliseconds (inclusive)
+ * @param {number} stepMs default 60000
+ * @return {Promise<Array<Array<{lat: number, lon: number, t: number}>>>}
+ */
+const propGeodeticBulk = async (elsets, start, end, stepMs = 60000) => {
+    const grid = buildTimeGrid(start, end, stepMs, true);
+    if (elsets.length === 0 || grid.length === 0) {
+        return elsets.map(() => []);
+    }
+    const satrecs = elsetsToSatrecs(elsets);
+    const dates = grid.map((t) => new Date(t));
+
+    const runtime = await getBulkRuntime();
+    const propagator = getOrCreateBulkPropagator({
+        runtime,
+        key: "eci+gmst+geo",
+        makeCalculators: () => [
+            new EciBaseCalculator(),
+            new GmstCalculator(),
+            new GeodeticPositionCalculator(),
+        ],
+        satRecsCount: satrecs.length,
+        datesCount: dates.length,
+    });
+    propagator.setSatRecs(satrecs);
+    propagator.setDates(dates);
+    propagator.run();
+
+    const {eci, geodeticPosition} = propagator.getRawOutput();
+    // KNOWN satellite.js@7.0.0 BUG / docs error: the
+    // `GeodeticPositionCalculator` raw layout is documented as
+    // `[lat, lon, height, ...]`, and `getFormattedOutput()` exposes fields
+    // `{latitude: raw[0], longitude: raw[1], height: raw[2]}` — but the
+    // physical values are SWAPPED. Empirically, against the canonical JS
+    // `eciToGeodetic` path:
+    //   raw[3*k + 0] -> physical LONGITUDE (in radians)
+    //   raw[3*k + 1] -> physical LATITUDE  (in radians)
+    //   raw[3*k + 2] -> height (km)
+    // We map raw -> {lat, lon} accordingly so `propGeodeticBulk` is exactly
+    // value-equivalent to `propGeodetic`. If a future satellite.js release
+    // fixes this upstream, swap the indices back here.
+    const out = new Array(satrecs.length);
+    const m = dates.length;
+    for (let s = 0; s < satrecs.length; s++) {
+        const positions = new Array(m);
+        let satFailed = false;
+        for (let d = 0; d < m; d++) {
+            const errIdx = s * m + d;
+            if (eci.error[errIdx] !== 0) {
+                satFailed = true;
+                break;
+            }
+            const vec = (s * m + d) * 3;
+            positions[d] = {
+                lat: geodeticPosition[vec + 1] * RAD2DEG,
+                lon: geodeticPosition[vec] * RAD2DEG,
+                t: grid[d],
+            };
+        }
+        out[s] = satFailed ? [] : positions;
+    }
+    return out;
+};
+
+/**
+ * WASM-backed bulk look-angles primitive. Computes (azimuth, elevation,
+ * rangeSat) for every satellite at every supplied date relative to a single
+ * observer (Geodetic location, **radians + km** as required by satellite.js
+ * v7 — `{latitude, longitude, height}`).
+ *
+ * Unlike `propBulk` and `propGeodeticBulk` this primitive takes an explicit
+ * `dates` array (rather than start/end/step) because look-angles consumers
+ * typically already hold the date list (e.g. observation timestamps in
+ * `GetResiduals`) and synthesizing a regular grid would re-impose JS-side
+ * step math the WASM pipeline is meant to avoid.
+ *
+ * Returns `Array<Array<{azimuth, elevation, rangeSat, t}>>` indexed
+ * `[satIdx][dateIdx]`, with angles in **radians** and `rangeSat` in km. On
+ * any SGP4 error for a satellite that satellite's entire output is `[]`.
+ *
+ * @param {Array<{Line1: string, Line2: string}>} elsets
+ * @param {Date[]|number[]} dates
+ * @param {{latitude: number, longitude: number, height: number}} observerGd
+ *   Observer position in radians (lat/lon) and km (height).
+ * @return {Promise<Array<Array<{azimuth: number, elevation: number, rangeSat: number, t: number}>>>}
+ */
+const propLookAnglesBulk = async (elsets, dates, observerGd) => {
+    if (elsets.length === 0 || dates.length === 0) {
+        return elsets.map(() => []);
+    }
+    const satrecs = elsetsToSatrecs(elsets);
+    const dateObjs = dates.map((d) => (d instanceof Date ? d : new Date(d)));
+    const ts = dateObjs.map((d) => d.getTime());
+
+    const runtime = await getBulkRuntime();
+    const propagator = getOrCreateBulkPropagator({
+        runtime,
+        key: "eci+gmst+ecf+lookAngles",
+        makeCalculators: () => [
+            new EciBaseCalculator(),
+            new GmstCalculator(),
+            new EcfPositionCalculator(),
+            new LookAnglesCalculator(),
+        ],
+        satRecsCount: satrecs.length,
+        datesCount: dateObjs.length,
+    });
+    propagator.setSatRecs(satrecs);
+    propagator.setDates(dateObjs);
+    propagator.run({lookAngles: {observer: observerGd}});
+
+    const {eci, lookAngles} = propagator.getRawOutput();
+    // lookAngles layout: [sat0 date0 (az, el, range), sat0 date1, ...]
+    const out = new Array(satrecs.length);
+    const m = dateObjs.length;
+    for (let s = 0; s < satrecs.length; s++) {
+        const samples = new Array(m);
+        let satFailed = false;
+        for (let d = 0; d < m; d++) {
+            const errIdx = s * m + d;
+            if (eci.error[errIdx] !== 0) {
+                satFailed = true;
+                break;
+            }
+            const vec = (s * m + d) * 3;
+            samples[d] = {
+                azimuth: lookAngles[vec],
+                elevation: lookAngles[vec + 1],
+                rangeSat: lookAngles[vec + 2],
+                t: ts[d],
+            };
+        }
+        out[s] = satFailed ? [] : samples;
+    }
+    return out;
+};
+
+export {
+    // `buildTimeGrid` is intentionally NOT exported: it is consumed only by
+    // `propBulk` / `propGeodeticBulk` inside this module. Keeping it private
+    // avoids polluting the public `@saber-usa/node-common` surface with a
+    // helper that exists purely to bridge the JS-path loop semantics to the
+    // WASM `setDates(Date[])` API.
+    elsetsToSatrecs, // used by `./wasmAstro.js#getGeoShadowZonesBulk`
+    propBulk,
+    propGeodeticBulk,
+    propLookAnglesBulk,
+};