@saber-usa/node-common 1.7.18 → 1.7.20

package/src/astro.js

@@ -793,6 +793,12 @@ const propGeodetic = (elset, start, end, stepMs = 60000) => {
     return positions;
 };
 
+// WASM-backed bulk primitives (`propBulk`, `propGeodeticBulk`,
+// `propLookAnglesBulk`) live in `./wasmProp/primitives.js`. The sync primitives
+// above remain the canonical path for single-satellite / small-N callers;
+// the bulk siblings are exposed through the barrel at `./wasmProp/index.js` and
+// re-exported from `./index.js`. See `docs/BULK_PROPAGATION.md`.
+
 const doesLineSegmentSphereIntersect = (linePoint0, linePoint1, circleCenter, circleRadius) => {
     // From Space Cockpit
     // http://www.codeproject.com/Articles/19799/Simple-Ray-Tracing-in-C-Part-II-Triangles-Intersec
@@ -848,6 +854,17 @@ const doesLineSegmentIntersectEarth = (start, end) => {
         {x: 0, y: 0, z: 0}, WGS72_EARTH_EQUATORIAL_RADIUS_KM);
 };
 
+const getRIC = (prim, target) => {
+    const deltaR = {
+        x: prim.p.x - target.p.x,
+        y: prim.p.y - target.p.y,
+        z: prim.p.z - target.p.z,
+    };
+    const cartToRICMatrix = cartesianToRIC(prim.p, prim.v);
+    const ricP = multiplyVector(deltaR, cartToRICMatrix);
+    return ricP;
+};
+
 /**
  * Given primary and target ephems, calculate the time-based, radial, intrack, and crosstrack data
  *
@@ -881,13 +898,7 @@ const getTRIC = (pEphem, tEphem) => {
         datamodes.push(prim.datamode + ", " + target.datamode);
 
         // Calculate RIC values.
-        const deltaR = {
-            x: prim.p.x - target.p.x,
-            y: prim.p.y - target.p.y,
-            z: prim.p.z - target.p.z,
-        };
-        const cartToRICMatrix = cartesianToRIC(prim.p, prim.v);
-        const ricP = multiplyVector(deltaR, cartToRICMatrix);
+        const ricP = getRIC(prim, target);
         r.push(-1 * Math.round(ricP.x * 10000) / 10000);
         i.push(-1 * Math.round(ricP.y * 10000) / 10000);
         c.push(-1 * Math.round(ricP.z * 10000) / 10000);
@@ -1725,85 +1736,122 @@ const cartesianToElsetElements = (pv, epoch) => {
  * @param {Integer} endTime, end time of the analysis, Unix milliseconds
  * @return {Array} Array of RPO data objects
  */
-const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
+/**
+ * Pure assembly helper for a single LEO RPO comparison row. Takes the primary
+ * and threat ephemerides (already produced by either the JS `prop` path or
+ * the WASM `propBulk` path) and returns the assembled result object. Shared
+ * by `getLeoRpoData` and `getLeoRpoDataBulk` to guarantee the JS and WASM
+ * variants emit byte-identical structures.
+ *
+ * Returns `undefined` if either ephemeris is missing or the lengths do not
+ * agree (which mirrors the original guard, including the case where the
+ * threat re-entered the atmosphere mid-window).
+ *
+ * @param {Object} s threat elset / metadata record
+ * @param {Array<{p:number[],v:number[],t:number}>} pEphem primary ephemeris
+ * @param {Array<{p:number[],v:number[],t:number}>} sEphem threat ephemeris
+ * @return {Object|undefined}
+ */
+const assembleLeoRpoResult = (s, pEphem, sEphem, includeRIC=false) => {
+    if (!isDefined(pEphem)
+        || !isDefined(sEphem)
+        || pEphem.length === 0
+        || pEphem.length !== sEphem.length) {
+        return undefined;
+    }
+
+    const aResult = {
+        line1: s.Line1,
+        line2: s.Line2,
+        epoch: s.Epoch,
+        name: s.CommonName,
+        rank: s.Rank ?? "",
+        satNo: s.SatNo,
+        inclination: s.Inclination,
+        raan: s.Raan,
+        source: s.Source,
+        datamode: s.DataMode,
+        sma: s.SemiMajorAxis,
+        country: s.CountryId,
+        flag: s.Flag,
+        poca: 9999999999,
+        toca: "",
+        tocaString: "",
+        planeDiff: 0,
+        incDiff: s.incDiff,
+        raanDiff: s.raanDiff,
+        semiMajorDiff: s.semiMajorDiff,
+        raanDrift: s.RaanPrecessionDegreesPerDay,
+        ...(includeRIC ? {
+            r: [],
+            i: [],
+            c: [],
+            d: [],
+            t: [],
+        } : {})
+    };
+
+    const pv1 = {position: pEphem[0].p, velocity: pEphem[0].v};
+    const pv2 = {position: sEphem[0].p, velocity: sEphem[0].v};
+    aResult.di = angleBetweenPlanes(pv1, pv2);
+    const dv = planeChangeDeltaV(pv1, pv2);
+    aResult.dv = {
+        i: Math.round(dv.i * 1000) / 1000,
+        c: Math.round(dv.c * 1000) / 1000,
+    };
+
+    for (let i = 0; i < pEphem.length; i++) {
+        const prim = pEphem[i];
+        const target = sEphem[i];
+        
+        const distKm = dist(prim.p, target.p);
+
+        if(includeRIC) {
+            const ricP = getRIC(prim, target);
+
+            aResult.r.push(-1 * ricP.x);
+            aResult.i.push(-1 * ricP.y);
+            aResult.c.push(-1 * ricP.z);
+
+            aResult.t.push(prim.t);
+            
+            aResult.d.push(distKm);
+        }
+
+        if (distKm < aResult.poca) {
+            aResult.poca = distKm;
+            aResult.toca = new Date(prim.t).toISOString();
+            aResult.tocaString = getTimeDifference(aResult.toca);
+        }
+    }
+
+    aResult.danger = (aResult.di === 0 || aResult.poca === 0)
+        ? 1000
+        : 1 / (aResult.di * aResult.poca);
+    return aResult;
+};
+
+const getLeoRpoData = (line1, line2, sats, startTime, endTime, includeRIC=false) => {
     const results = [];
     const pSatRec = checkTle(line1, line2);
     if (!isDefined(pSatRec)) {return results;}
 
     const start = new Date(startTime).getTime();
     const end = new Date(endTime).getTime();
-    const pElset = {
-        Line1: line1,
-        Line2: line2,
-    };
+    const pElset = {Line1: line1, Line2: line2};
     const pEphem = prop(pElset, start, end, 10000);
     if (pEphem.length === 0) {return results;} // Primary may have re-entered the atmosphere
 
-    sats.forEach( (s) => {
+    sats.forEach((s) => {
         const sEphem = prop(s, start, end, 10000);
-        if (!isDefined(pEphem)
-            || !isDefined(sEphem)
-            || pEphem.length !== sEphem.length) {
-            return;
-        }
-
-        const aResult = {
-            line1: s.Line1,
-            line2: s.Line2,
-            epoch: s.Epoch,
-            name: s.CommonName,
-            rank: s.Rank ?? "",
-            satNo: s.SatNo,
-            inclination: s.Inclination,
-            raan: s.Raan,
-            source: s.Source,
-            datamode: s.DataMode,
-            sma: s.SemiMajorAxis,
-            country: s.CountryId,
-            flag: s.Flag,
-            poca: 9999999999,
-            toca: "",
-            tocaString: "",
-            planeDiff: 0,
-            incDiff: s.incDiff,
-            raanDiff: s.raanDiff,
-            semiMajorDiff: s.semiMajorDiff,
-            raanDrift: s.RaanPrecessionDegreesPerDay,
-        };
-
-        const pv1 = {
-            position: pEphem[0].p,
-            velocity: pEphem[0].v,
-        };
-        const pv2 = {
-            position: sEphem[0].p,
-            velocity: sEphem[0].v,
-        };
-        aResult.di = angleBetweenPlanes(pv1, pv2);
-        aResult.dv = planeChangeDeltaV(pv1, pv2);
-        aResult.dv = {
-            i: Math.round(aResult.dv.i*1000)/1000,
-            c: Math.round(aResult.dv.c*1000)/1000,
-        }; // Round to 3 decimals
-
-        // Find the distance at each time step
-        for (let i=0; i<pEphem.length; i++) {
-            const distKm = dist(pEphem[i].p, sEphem[i].p);
-            if (distKm < aResult.poca) {
-                aResult.poca = distKm;
-                aResult.toca = new Date(pEphem[i].t).toISOString();
-                aResult.tocaString = getTimeDifference(aResult.toca);
-            }
-        }
-
-        // Calc danger score (account for di of 0)
-        aResult.danger = (aResult.di === 0
-                        || aResult.poca === 0) ? 1000 : 1/(aResult.di*aResult.poca);
-        results.push(aResult);
+        const row = assembleLeoRpoResult(s, pEphem, sEphem, includeRIC);
+        if (isDefined(row)) {results.push(row);}
     });
     return results;
 };
 
+// `getLeoRpoDataBulk` extracted to `./wasmProp/wasmAstro.js`.
+
 
 /**
  * Get GEO RPO data for a given target satellite and a set of potential threat satellites.
@@ -1815,208 +1863,270 @@ const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
  * @param {Integer} lonTime, datetime to analyze longitude and lon drift at, Unix milliseconds
  * @return {Array<Objects>}, Array of RPO data objects
  */
-const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
-    const start = new Date(startTime).getTime();
-    const end = new Date(endTime).getTime();
-    const pEphem = prop({
-        Line1: line1,
-        Line2: line2,
-    }, start, end, 60000);
-    if (pEphem.length === 0) {return results;} // Primary may have re-entered the atmosphere
+/**
+ * GEO-specific signed longitude-difference rate. Encodes whether the two
+ * satellites' longitudes are converging (negative magnitude) or diverging
+ * (positive magnitude) given their respective east-positive drifts. Lifted
+ * verbatim out of `getGeoRpoData`'s nested closure so both the JS and WASM
+ * variants share identical drift accounting.
+ *
+ * @param {Number} lon1 satellite-1 longitude (degrees, signed)
+ * @param {Number} drift1 satellite-1 drift, degrees/day east-positive
+ * @param {Number} lon2 satellite-2 longitude (degrees, signed)
+ * @param {Number} drift2 satellite-2 drift, degrees/day east-positive
+ * @return {Number}
+ */
+const geoRelativeLonDrift = (lon1, drift1, lon2, drift2) => {
+    let closing = false;
+    if (lon1 > lon2) {
+        closing = (drift1 * drift2 > 0 && drift1 < drift2)
+            || (drift1 * drift2 < 0 && drift1 < 0);
+    } else if (lon2 > lon1) {
+        closing = (drift1 * drift2 > 0 && drift2 < drift1)
+            || (drift1 * drift2 < 0 && drift1 > 0);
+    }
+    const difference = drift1 - drift2;
+    return closing ? -Math.abs(difference) : Math.abs(difference);
+};
 
-    const lonEvalTime = lonTime ? new Date(lonTime) : new Date(end);
+/**
+ * Pure assembly helper for a single GEO RPO comparison row. Identical math
+ * to the original inline body of `getGeoRpoData`, factored out so the
+ * JS-path (`getGeoRpoData`) and WASM-path (`getGeoRpoDataBulk`) emit
+ * byte-equivalent structures.
+ *
+ * `getLonAndDrift` is JS-only by design (see the `low-value` opportunity
+ * list in `docs/BULK_PROPAGATION.md`); both call sites compute it
+ * upstream and pass the precomputed result in.
+ *
+ * Returns `undefined` if either ephemeris is missing or the lengths do not
+ * match (mirrors the original guard).
+ *
+ * @param {Object} s threat elset / metadata record
+ * @param {Array<{p:number[],v:number[],t:number}>} pEphem primary ephemeris
+ * @param {Array<{p:number[],v:number[],t:number}>} sEphem threat ephemeris
+ * @param {Object} pLonAndDrift output of `getLonAndDrift(primary)`
+ * @param {Object} sLonAndDrift output of `getLonAndDrift(threat)`
+ * @return {Object|undefined}
+ */
+const assembleGeoRpoResult = (s, pEphem, sEphem, pLonAndDrift, sLonAndDrift, includeRIC=false) => {
+    if (!isDefined(pEphem)
+        || !isDefined(sEphem)
+        || pEphem.length === 0
+        || pEphem.length !== sEphem.length) {
+        return undefined;
+    }
+
+    const aResult = {
+        line1: s.Line1,
+        line2: s.Line2,
+        epoch: s.Epoch,
+        name: s.CommonName,
+        rank: s.Rank ?? "",
+        satNo: s.SatNo,
+        source: s.Source,
+        country: s.CountryId,
+        datamode: s.DataMode,
+        flag: s.Flag,
+        poca: 9999999999,
+        toca: "",
+        tocaString: "",
+        incDiff: s.incDiff,
+        longitude: (sLonAndDrift.longitude + 360) % 360,
+        lonDiff: null,
+        relativeDrift: null,
+        di: null,
+        dv: null,
+        danger: null,
+        ...(includeRIC ? {
+            r: [],
+            i: [],
+            c: [],
+            d: [],
+            t: [],
+        } : {})
+    };
 
-    const pLonAndDrift = getLonAndDrift(line1, line2, lonEvalTime);
+    const lonDiff = Math.abs(
+        (pLonAndDrift.longitude + 360) % 360
+        - (sLonAndDrift.longitude + 360) % 360,
+    );
+    aResult.lonDiff = Math.min(lonDiff, 360 - lonDiff);
+
+    aResult.relativeDrift = geoRelativeLonDrift(
+        pLonAndDrift.longitude,
+        pLonAndDrift.lonDriftDegreesPerDay,
+        sLonAndDrift.longitude,
+        sLonAndDrift.lonDriftDegreesPerDay,
+    );
 
-    const getLonDiff = (lon1, drift1, lon2, drift2) => {
-        const closing = lon1 > lon2
-            ? (drift1 * drift2 > 0 && drift1 < drift2) || (drift1 * drift2 < 0 && drift1 < 0) // Sat1 is more Eastward
-            : lon2 > lon1
-                ? (drift1 * drift2 > 0 && drift2 < drift1) || (drift1 * drift2 < 0 && drift1 > 0) // Sat2 is more Eastward
-                : false;
-        const difference = drift1 - drift2;
-        return closing ? -1 * Math.abs(difference) : Math.abs(difference);
+    const pv1 = {position: pEphem[0].p, velocity: pEphem[0].v};
+    const pv2 = {position: sEphem[0].p, velocity: sEphem[0].v};
+    aResult.di = angleBetweenPlanes(pv1, pv2);
+    const dv = planeChangeDeltaV(pv1, pv2);
+    aResult.dv = {
+        i: Math.round(dv.i * 1000) / 1000,
+        c: Math.round(dv.c * 1000) / 1000,
     };
 
-    const results = [];
-    sats.forEach((s) => {
-        const aResult = {
-            line1: s.Line1,
-            line2: s.Line2,
-            epoch: s.Epoch,
-            name: s.CommonName,
-            rank: s.Rank ?? "",
-            satNo: s.SatNo,
-            source: s.Source,
-            country: s.CountryId,
-            datamode: s.DataMode,
-            flag: s.Flag,
-            poca: 9999999999,
-            toca: "",
-            tocaString: "",
-            incDiff: s.incDiff,
-            longitude: null,
-            lonDiff: null,
-            relativeDrift: null,
-            di: null,
-            dv: null,
-            danger: null,
-        };
+    for (let i = 0; i < pEphem.length; i++) {
+        const prim = pEphem[i];
+        const target = sEphem[i];
+        
+        const distKm = dist(prim.p, target.p);
+
+        if(includeRIC) {
+            const ricP = getRIC(prim, target);
 
-        const sEphem = prop({
-            Line1: aResult.line1,
-            Line2: aResult.line2,
-        }, start, end, 60000);
-        if (!isDefined(pEphem)
-            || !isDefined(sEphem)
-            || pEphem.length !== sEphem.length) {
-            return;
+            aResult.r.push(-1 * ricP.x);
+            aResult.i.push(-1 * ricP.y);
+            aResult.c.push(-1 * ricP.z);
+
+            aResult.t.push(prim.t);
+            
+            aResult.d.push(distKm);
         }
-        const sLonAndDrift = getLonAndDrift(s.Line1, s.Line2, lonEvalTime);
-        aResult.longitude = (sLonAndDrift.longitude + 360) % 360; // Normalize to 0-360
 
-        const lonDiff = Math.abs(
-            (pLonAndDrift.longitude + 360) % 360
-            - (sLonAndDrift.longitude + 360) % 360,
-        );
-        // To ensure that the smallest "short-way" lon diff is considered
-        aResult.lonDiff = Math.min(lonDiff, 360 - lonDiff);
-
-        aResult.relativeDrift = getLonDiff(
-            pLonAndDrift.longitude,
-            pLonAndDrift.lonDriftDegreesPerDay,
-            sLonAndDrift.longitude,
-            sLonAndDrift.lonDriftDegreesPerDay);
-        const pv1 = {
-            position: pEphem[0].p,
-            velocity: pEphem[0].v,
-        };
-        const pv2 = {
-            position: sEphem[0].p,
-            velocity: sEphem[0].v,
-        };
-        aResult.di = angleBetweenPlanes(pv1, pv2);
-        aResult.dv = {
-            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000)/1000,
-            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000)/1000,
-        }; // Round to 3 decimals
-
-        for (let i=0; i<pEphem.length; i++) {
-            const distKm = dist(pEphem[i].p, sEphem[i].p);
-            if (distKm < aResult.poca) {
-                aResult.poca = distKm;
-                aResult.toca = new Date(pEphem[i].t).toISOString();
-                aResult.tocaString = getTimeDifference(aResult.toca);
-            }
+        if (distKm < aResult.poca) {
+            aResult.poca = distKm;
+            aResult.toca = new Date(prim.t).toISOString();
+            aResult.tocaString = getTimeDifference(aResult.toca);
         }
-        // Calc danger score (account for di of 0)
-        aResult.danger = (aResult.di === 0
-                        || aResult.poca === 0) ? 1000 : 1/(aResult.di*aResult.poca);
+    }
+
+    aResult.danger = (aResult.di === 0 || aResult.poca === 0)
+        ? 1000
+        : 1 / (aResult.di * aResult.poca);
+    return aResult;
+};
+
+const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime, includeRIC=false) => {
+    const results = [];
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+    const pEphem = prop({Line1: line1, Line2: line2}, start, end, 60000);
+    if (!isDefined(pEphem) || pEphem.length === 0) {
+        return results; // Primary may have re-entered the atmosphere
+    }
+
+    const lonEvalTime = lonTime ? new Date(lonTime) : new Date(end);
+    const pLonAndDrift = getLonAndDrift(line1, line2, lonEvalTime);
 
-        results.push(aResult);
+    sats.forEach((s) => {
+        const sEphem = prop({Line1: s.Line1, Line2: s.Line2}, start, end, 60000);
+        const sLonAndDrift = getLonAndDrift(s.Line1, s.Line2, lonEvalTime);
+        const row = assembleGeoRpoResult(s, pEphem, sEphem, pLonAndDrift, sLonAndDrift, includeRIC);
+        if (isDefined(row)) {results.push(row);}
     });
 
     return results;
 };
 
-const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
-    // Accuracy is 86400 pooints on a 360 circle (i.e. 0.00416 deg per second)
+// `getGeoRpoDataBulk` extracted to `./wasmProp/wasmAstro.js`.
 
-    // Define the TLE parameters of a template TLE in GEO
-    const tleLine1 = "1 00000U 00000A   24079.98445361 -.00000000  00000-0 -00000-0 0 00000";
-    const tleLine2Temp = "2 00000 000.0000 000.0000 0000000 000.0000 XXX.XXXX 01.00000000000000";
-    // Number of steps for the mean anomaly
-    const steps = 360 / accuracySecondsDeg;
-    // Loop over the range of mean anomalies
-    const res = [];
+/** GEO mean-anomaly TLE template used by the shadow-zone scan. The
+ *  `XXX.XXXX` token is substituted with each candidate mean anomaly.
+ *  TLE lines are fixed-length by definition, hence the disable-next-line. */
+// eslint-disable-next-line max-len
+const SHADOW_ZONE_TLE_LINE_1 = "1 00000U 00000A   24079.98445361 -.00000000  00000-0 -00000-0 0 00000";
+// eslint-disable-next-line max-len
+const SHADOW_ZONE_TLE_LINE_2_TEMPLATE = "2 00000 000.0000 000.0000 0000000 000.0000 XXX.XXXX 01.00000000000000";
+
+/**
+ * Build the array of GEO mean-anomaly elsets the shadow-zone scan
+ * exercises. Pure; no propagation. Produces `360 / accuracySecondsDeg`
+ * elsets, one for each mean anomaly slot, in increasing order.
+ *
+ * @param {Number} accuracySecondsDeg degrees per slot
+ * @return {Array<{Line1:string, Line2:string}>}
+ */
+const buildShadowZoneElsets = (accuracySecondsDeg) => {
+    // Use Math.floor so fractional `360 / accuracySecondsDeg` (e.g.
+    // accuracy values that don't divide 360 exactly) still produce a
+    // valid integer step count. Matches the original loop's `i < steps`
+    // behavior, which also truncated.
+    const steps = Math.floor(360 / accuracySecondsDeg);
+    const out = new Array(steps);
     for (let i = 0; i < steps; i++) {
-        // Calculate the mean anomaly for this step
         const meanAnomaly = i * accuracySecondsDeg;
-        // Format the mean anomaly into the TLE line
-        // Round the mean anomaly to two decimal places
         const roundedMeanAnomaly = meanAnomaly.toFixed(4);
-        // Format the mean anomaly into the TLE line
-        const tleLine2 = tleLine2Temp.replace("XXX.XXXX", roundedMeanAnomaly.padStart(8, "0"));
-        // Generate the satrec object
-        const p = propagate(twoline2satrec(tleLine1, tleLine2), time).position;
-        res.push({
-            ecl: getEclipseStatus(time, [p.x, p.y, p.z]),
-            geolon: eciToGeodetic(p, gstime(time)).longitude*RAD2DEG,
-        });
+        const tleLine2 = SHADOW_ZONE_TLE_LINE_2_TEMPLATE.replace(
+            "XXX.XXXX", roundedMeanAnomaly.padStart(8, "0"),
+        );
+        out[i] = {Line1: SHADOW_ZONE_TLE_LINE_1, Line2: tleLine2};
     }
-    // Find the sun zone, umbra zone, and two penumbra zones.
-    const ints = [];
-
-    // Open the first zone. Note that this may not be the start of this zone but somewhere in the middle.
-    // It's just the start of the mean anomaly seen as a circular buffer.
-    ints.push({
-        ecl: res[0].ecl,
-    });
+    return out;
+};
 
-    for (let i=1; i<=res.length-1; i++) {
-        // Compare with the previous eclipse state
-        if (res[i].ecl!==res[i-1].ecl) {
-            // Close the previous zone
-            ints.at(-1).stopDeg = res[i-1].geolon;
+/**
+ * Pure zone-analysis pass. Takes the per-slot
+ * `[{ecl, geolon}, ...]` series produced by either the JS or WASM scan
+ * and returns `{penStartWestLon, penStartEastLon}` exactly as the
+ * original `getGeoShadowZones` does.
+ *
+ * Lifted out of the original function body without semantic changes:
+ * - identical interval seam-stitching across the 360°/0° wraparound,
+ * - identical "fully lit GEO belt" early return,
+ * - identical penumbra-only vs. umbra+penumbra branching.
+ *
+ * @param {Array<{ecl:string, geolon:number}>} res
+ * @return {{penStartWestLon:?number, penStartEastLon:?number}}
+ */
+const analyzeShadowZoneSeries = (res) => {
+    const ints = [{ecl: res[0].ecl}];
 
-            // Open a new zone
-            ints.push({
-                ecl: res[i].ecl,
-                startDeg: res[i].geolon,
-            });
+    for (let i = 1; i <= res.length - 1; i++) {
+        if (res[i].ecl !== res[i - 1].ecl) {
+            ints.at(-1).stopDeg = res[i - 1].geolon;
+            ints.push({ecl: res[i].ecl, startDeg: res[i].geolon});
         }
     }
-    // With this process, the first interval will have a stop lon but not a start lon, and
-    // the final interval will have a start lon but not a stop lon.
-    // Stitch the first and last intervals together.
 
-    // If not dates are pushed on the first interval, it means it never closed, so it's a fully lit GEO belt.
-    // If there's only sun, return null values
-    if ( ints.length===1
-        && ints.filter((x)=>x.ecl === "SUN").length===1) {
-        return {
-            penStartWestLon: null,
-            penStartEastLon: null,
-        };
+    if (ints.length === 1
+        && ints.filter((x) => x.ecl === "SUN").length === 1) {
+        return {penStartWestLon: null, penStartEastLon: null};
     }
 
     ints[0].startDeg = ints.at(-1).startDeg;
     ints.pop();
 
-    if (
-        ints.filter((x)=>x.ecl === "UMBRA").length===0
-        && ints.some((x)=>x.ecl === "PENUMBRA")) {
-        // If there's no umbra but penumbra exists, return the perumbra values
-
-        // Extract the penumbra interval. In the absence of umbra, a single penumbra interval should exist.
-        const penumbraInt = ints.find((x)=>x.ecl === "PENUMBRA");
+    if (ints.filter((x) => x.ecl === "UMBRA").length === 0
+        && ints.some((x) => x.ecl === "PENUMBRA")) {
+        const penumbraInt = ints.find((x) => x.ecl === "PENUMBRA");
         return {
             penStartWestLon: wrapToRange(penumbraInt.startDeg, 0, 360),
             penStartEastLon: wrapToRange(penumbraInt.stopDeg, 0, 360),
         };
-    } else {
-        // If sun, umbra, penumbra intervals exist
-
-        const umbra = ints.find((x)=>x.ecl === "UMBRA");
+    }
 
-        const umbraStart360 = wrapToRange(umbra.startDeg, 0, 360);
-        const umbraStop360 = wrapToRange(umbra.stopDeg, 0, 360);
-        // Assuming a spherical earth for this purpose, the two penumbra intervals should be equal.
-        // Compute the angle of one of the penumbra intervals, the one that does not contain the disconituity.
-        const penumbraInts = ints.filter((x)=>x.ecl === "PENUMBRA");
-        const chosenPenumbraInt = penumbraInts[0].startDeg > penumbraInts[0].stopDeg
-            ? penumbraInts[1] : penumbraInts[0];
-        const penumbraAngle = chosenPenumbraInt.stopDeg - chosenPenumbraInt.startDeg;
-        const penumbraStart = umbraStart360 - penumbraAngle;
-        const penumbraStop = umbraStop360 + penumbraAngle;
+    const umbra = ints.find((x) => x.ecl === "UMBRA");
+    const umbraStart360 = wrapToRange(umbra.startDeg, 0, 360);
+    const umbraStop360 = wrapToRange(umbra.stopDeg, 0, 360);
+    const penumbraInts = ints.filter((x) => x.ecl === "PENUMBRA");
+    const chosenPenumbraInt = penumbraInts[0].startDeg > penumbraInts[0].stopDeg
+        ? penumbraInts[1] : penumbraInts[0];
+    const penumbraAngle = chosenPenumbraInt.stopDeg - chosenPenumbraInt.startDeg;
+    return {
+        penStartWestLon: umbraStart360 - penumbraAngle,
+        penStartEastLon: umbraStop360 + penumbraAngle,
+    };
+};
 
+const getGeoShadowZones = (time, accuracySecondsDeg = 0.00416 * 100) => {
+    // Default accuracy: 86400 points on the 360° circle (~0.00416 deg/sec).
+    const elsets = buildShadowZoneElsets(accuracySecondsDeg);
+    const res = elsets.map(({Line1, Line2}) => {
+        const p = propagate(twoline2satrec(Line1, Line2), time).position;
         return {
-            penStartWestLon: penumbraStart,
-            penStartEastLon: penumbraStop,
+            ecl: getEclipseStatus(time, [p.x, p.y, p.z]),
+            geolon: eciToGeodetic(p, gstime(time)).longitude * RAD2DEG,
         };
-    }
+    });
+    return analyzeShadowZoneSeries(res);
 };
 
+// `getGeoShadowZonesBulk` extracted to `./wasmProp/wasmAstro.js`.
+
 /** Returns the light intervals of an arbitrary satellite in strict GEO orbit.
  *
  * These intervals are generally equal in duration for all other GEO satellites.
@@ -2415,66 +2525,85 @@ const calculateLeoPhaseDifference = (pLine1, pLine2, tLine1, tLine2, time) => {
  * @param {Integer} stepMs, step time of the analysis in milliseconds, default 10s
  * @return {Array} Array of data objects
  */
-const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
-    const results = [];
-
-    const start = new Date(startTime).getTime();
-    const end = new Date(endTime).getTime();
-
-    const currentIndices = elsets.map((sat) => 0);
+/**
+ * Build the breakpoint schedule for `getLeoWaterfallData` /
+ * `getLeoWaterfallDataBulk`. The waterfall covers `[start, end]` divided
+ * into segments at every per-satellite elset epoch that falls strictly
+ * inside that range. Pure; no propagation.
+ *
+ * Each breakpoint is `{time, satIndex, elsetIndex?}`. The two synthetic
+ * sentinel breakpoints at `start` / `end` carry `satIndex: -1` so the
+ * segment loop can distinguish "edge of window" from "satellite epoch".
+ *
+ * @param {Array<Array<Object>>} elsets per-satellite elset arrays
+ * @param {Number} start Unix ms
+ * @param {Number} end Unix ms
+ * @return {Array<{time:number, satIndex:number, elsetIndex?:number}>}
+ */
+const buildWaterfallBreakpoints = (elsets, start, end) => {
     const breakpoints = [{time: start, satIndex: -1}, {time: end, satIndex: -1}];
     elsets.forEach((satElsets, i) => {
         breakpoints.push(...satElsets.map((e, j) => ({
             time: new Date(e.Epoch).getTime(),
             satIndex: i,
             elsetIndex: j,
-        })).filter((b) => b.time > start && b.time < end)); // ensure breakpoints are inside time range
+        })).filter((b) => b.time > start && b.time < end));
     });
     breakpoints.sort((a, b) => a.time - b.time);
+    return breakpoints;
+};
 
-    const satEphems = elsets.map((sat) => []);
-
-    for (let i = 0; i < breakpoints.length-1; i++) {
-        const bkpoint = breakpoints[i];
-        // if we start at breakpoints, it's irregular (since the epochs aren't in lockstep)
-        // we can force it to Math.ceil(segmentStart/stepMs)*stepMs for even steps but since the discrepancy
-        // is less than 10s in a plot over multiple days it's rather negligible
-        // also this makes it easier since we can check if its an epoch based on the segmentStart
-        const segmentStart = bkpoint.time;
-        const segmentEnd = breakpoints[i+1].time;
-
-        if (bkpoint.satIndex >= 0) { // this is a satellite's elset's epoch
-            currentIndices[bkpoint.satIndex] = bkpoint.elsetIndex;
-        }
-
-        currentIndices.forEach((elsetIndex, satIndex) => {
-            const elset = elsets[satIndex][elsetIndex];
-            const epoch = new Date(elset.Epoch).getTime();
-            const ephem = prop(elset, segmentStart, segmentEnd, stepMs);
-            satEphems[satIndex].push(...ephem.map((point, pointInd) => {
-                const osculatingElements = cartesianToKeplerian(
-                    multiply(posToArray(point.p), 1000), // km to m
-                    multiply(posToArray(point.v), 1000), // km/s to m/s
-                );
-                return {
-                    ...point,
-                    isEpoch: pointInd === 0 && bkpoint.satIndex === satIndex,
-                    epoch: epoch,
-                    satNo: elset.SatNo,
-                    name: elset.CommonName,
-                    source: elset.Source,
-                    raan: osculatingElements.raan, // deg
-                    raanPrecession: elset.RaanPrecessionDegreesPerDay,
-                    inclination: osculatingElements.i, // deg
-                };
-            }));
-        });
-    }
+/**
+ * Decorate a per-segment ephemeris with osculating elements and elset
+ * metadata. Identical post-processing as the original inline `.map()` in
+ * `getLeoWaterfallData`. Used by both the JS and WASM waterfall variants
+ * so the two emit byte-equivalent rows.
+ *
+ * `isEpoch` is `true` for the first point of the segment if-and-only-if
+ * the segment was opened by *this* satellite's elset epoch (matches the
+ * original `pointInd === 0 && bkpoint.satIndex === satIndex` check).
+ *
+ * @param {Array<{p:number[],v:number[],t:number}>} ephem segment ephemeris
+ * @param {Object} elset active elset for this satellite in this segment
+ * @param {{satIndex:number}} bkpoint segment-opening breakpoint
+ * @param {Number} satIndex index of the satellite in the original `elsets`
+ * @return {Array<Object>}
+ */
+const decorateWaterfallSegment = (ephem, elset, bkpoint, satIndex) => {
+    const epoch = new Date(elset.Epoch).getTime();
+    return ephem.map((point, pointInd) => {
+        const osculatingElements = cartesianToKeplerian(
+            multiply(posToArray(point.p), 1000), // km -> m
+            multiply(posToArray(point.v), 1000), // km/s -> m/s
+        );
+        return {
+            ...point,
+            isEpoch: pointInd === 0 && bkpoint.satIndex === satIndex,
+            epoch: epoch,
+            satNo: elset.SatNo,
+            name: elset.CommonName,
+            source: elset.Source,
+            raan: osculatingElements.raan, // deg
+            raanPrecession: elset.RaanPrecessionDegreesPerDay,
+            inclination: osculatingElements.i, // deg
+        };
+    });
+};
 
+/**
+ * Build the per-(time, satellite) waterfall result rows from the
+ * decorated ephemerides produced by {@link decorateWaterfallSegment}.
+ * Identical math to the second loop of the original `getLeoWaterfallData`.
+ * Pure; deterministic; shared by both variants.
+ *
+ * @param {Array<Array<Object>>} satEphems primary at index 0
+ * @return {Array<Object>}
+ */
+const assembleWaterfallRows = (satEphems) => {
+    const results = [];
     const pEphem = satEphems[0];
 
-    satEphems.forEach( (sEphem, satIndex) => {
-        // Find the distance at each time step
+    satEphems.forEach((sEphem, satIndex) => {
         for (let i = 0; i < pEphem.length; i++) {
             const pEphemPoint = pEphem[i];
             const sEphemPoint = sEphem[i];
@@ -2493,7 +2622,7 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
 
             if (satIndex > 0) { // not the primary
                 if (areCoordsEqual(pEphemPoint.p, sEphemPoint.p)) {
-                    catsAngle = 180; // they're in the same spot, so just say secondary can see primary
+                    catsAngle = 180;
                 } else {
                     catsAngle = angleBetween3DCoords(
                         pEphemPoint.p,
@@ -2501,7 +2630,6 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
                         getSunDirection(time),
                     );
                 }
-
                 const earthEclipsed = doesLineSegmentIntersectEarth(pEphemPoint.p, sEphemPoint.p);
                 const targetShadow = getEclipseStatus(time, posToArray(sEphemPoint.p));
                 targetVisibility = earthEclipsed ? "EARTH ECLIPSED" : targetShadow;
@@ -2529,6 +2657,40 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
     return results;
 };
 
+const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+
+    const breakpoints = buildWaterfallBreakpoints(elsets, start, end);
+    const currentIndices = elsets.map(() => 0);
+    const satEphems = elsets.map(() => []);
+
+    for (let i = 0; i < breakpoints.length - 1; i++) {
+        const bkpoint = breakpoints[i];
+        // Segment boundaries align with elset epochs, not multiples of `stepMs`.
+        // The intra-segment ephemeris drift (<= one step) is negligible at the
+        // multi-day plot resolution this function targets.
+        const segmentStart = bkpoint.time;
+        const segmentEnd = breakpoints[i + 1].time;
+
+        if (bkpoint.satIndex >= 0) {
+            currentIndices[bkpoint.satIndex] = bkpoint.elsetIndex;
+        }
+
+        currentIndices.forEach((elsetIndex, satIndex) => {
+            const elset = elsets[satIndex][elsetIndex];
+            const ephem = prop(elset, segmentStart, segmentEnd, stepMs);
+            satEphems[satIndex].push(
+                ...decorateWaterfallSegment(ephem, elset, bkpoint, satIndex),
+            );
+        });
+    }
+
+    return assembleWaterfallRows(satEphems);
+};
+
+// `getLeoWaterfallDataBulk` extracted to `./wasmProp/wasmAstro.js`.
+
 /**
  * Returns the minimum deltaV for a Lambert maneuver between two satellites,
  * within the given time range.
@@ -3325,6 +3487,18 @@ export {
     getGeoRpoData,
     getGeoShadowZones,
     getGeoLightIntervals,
+    // Shared pure assembly helpers, exported so `./wasmProp/wasmAstro.js` can
+    // consume them without duplicating logic. These are cross-path
+    // building blocks (used by both the JS-sync and WASM-async siblings)
+    // and are safe to call as ordinary utilities.
+    assembleLeoRpoResult,
+    geoRelativeLonDrift,
+    assembleGeoRpoResult,
+    buildShadowZoneElsets,
+    analyzeShadowZoneSeries,
+    buildWaterfallBreakpoints,
+    decorateWaterfallSegment,
+    assembleWaterfallRows,
     getEclipseStatus,
     estimateSlantRange,
     calculateNextApogeePerigeeTimes,