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

package/src/astro.js

@@ -793,12 +793,6 @@ 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
@@ -1731,78 +1725,6 @@ const cartesianToElsetElements = (pv, epoch) => {
  * @param {Integer} endTime, end time of the analysis, Unix milliseconds
  * @return {Array} Array of RPO data objects
  */
-/**
- * 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) => {
-    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,
-    };
-
-    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 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);
-        }
-    }
-
-    aResult.danger = (aResult.di === 0 || aResult.poca === 0)
-        ? 1000
-        : 1 / (aResult.di * aResult.poca);
-    return aResult;
-};
-
 const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
     const results = [];
     const pSatRec = checkTle(line1, line2);
@@ -1810,20 +1732,78 @@ const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
 
     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);
-        const row = assembleLeoRpoResult(s, pEphem, sEphem);
-        if (isDefined(row)) {results.push(row);}
+        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);
     });
     return results;
 };
 
-// `getLeoRpoDataBulk` extracted to `./wasmProp/wasmAstro.js`.
-
 
 /**
  * Get GEO RPO data for a given target satellite and a set of potential threat satellites.
@@ -1835,247 +1815,208 @@ 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
  */
-/**
- * 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);
-};
-
-/**
- * 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) => {
-    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,
-    };
-
-    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 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 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);
-        }
-    }
-
-    aResult.danger = (aResult.di === 0 || aResult.poca === 0)
-        ? 1000
-        : 1 / (aResult.di * aResult.poca);
-    return aResult;
-};
-
 const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
-    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 pEphem = prop({
+        Line1: line1,
+        Line2: line2,
+    }, start, end, 60000);
+    if (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);
 
+    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 results = [];
     sats.forEach((s) => {
-        const sEphem = prop({Line1: s.Line1, Line2: s.Line2}, start, end, 60000);
+        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,
+        };
+
+        const sEphem = prop({
+            Line1: aResult.line1,
+            Line2: aResult.line2,
+        }, start, end, 60000);
+        if (!isDefined(pEphem)
+            || !isDefined(sEphem)
+            || pEphem.length !== sEphem.length) {
+            return;
+        }
         const sLonAndDrift = getLonAndDrift(s.Line1, s.Line2, lonEvalTime);
-        const row = assembleGeoRpoResult(s, pEphem, sEphem, pLonAndDrift, sLonAndDrift);
-        if (isDefined(row)) {results.push(row);}
+        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);
+            }
+        }
+        // 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);
     });
 
     return results;
 };
 
-// `getGeoRpoDataBulk` extracted to `./wasmProp/wasmAstro.js`.
+const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
+    // Accuracy is 86400 pooints on a 360 circle (i.e. 0.00416 deg per second)
 
-/** 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);
+    // 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 = [];
     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);
-        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};
+        // 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,
+        });
     }
-    return out;
-};
+    // Find the sun zone, umbra zone, and two penumbra zones.
+    const ints = [];
 
-/**
- * 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 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,
+    });
 
-    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});
+    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;
+
+            // Open a new zone
+            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 (ints.length === 1
-        && ints.filter((x) => x.ecl === "SUN").length === 1) {
-        return {penStartWestLon: null, penStartEastLon: null};
+    // 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,
+        };
     }
 
     ints[0].startDeg = ints.at(-1).startDeg;
     ints.pop();
 
-    if (ints.filter((x) => x.ecl === "UMBRA").length === 0
-        && ints.some((x) => x.ecl === "PENUMBRA")) {
-        const penumbraInt = ints.find((x) => x.ecl === "PENUMBRA");
+    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");
         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);
-    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 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 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 {
-            ecl: getEclipseStatus(time, [p.x, p.y, p.z]),
-            geolon: eciToGeodetic(p, gstime(time)).longitude * RAD2DEG,
+            penStartWestLon: penumbraStart,
+            penStartEastLon: penumbraStop,
         };
-    });
-    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.
@@ -2474,85 +2415,66 @@ 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
  */
-/**
- * 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 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);
     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));
+        })).filter((b) => b.time > start && b.time < end)); // ensure breakpoints are inside time range
     });
     breakpoints.sort((a, b) => a.time - b.time);
-    return breakpoints;
-};
 
-/**
- * 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
-        };
-    });
-};
+    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
+                };
+            }));
+        });
+    }
 
-/**
- * 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) => {
+    satEphems.forEach( (sEphem, satIndex) => {
+        // Find the distance at each time step
         for (let i = 0; i < pEphem.length; i++) {
             const pEphemPoint = pEphem[i];
             const sEphemPoint = sEphem[i];
@@ -2571,7 +2493,7 @@ const assembleWaterfallRows = (satEphems) => {
 
             if (satIndex > 0) { // not the primary
                 if (areCoordsEqual(pEphemPoint.p, sEphemPoint.p)) {
-                    catsAngle = 180;
+                    catsAngle = 180; // they're in the same spot, so just say secondary can see primary
                 } else {
                     catsAngle = angleBetween3DCoords(
                         pEphemPoint.p,
@@ -2579,6 +2501,7 @@ const assembleWaterfallRows = (satEphems) => {
                         getSunDirection(time),
                     );
                 }
+
                 const earthEclipsed = doesLineSegmentIntersectEarth(pEphemPoint.p, sEphemPoint.p);
                 const targetShadow = getEclipseStatus(time, posToArray(sEphemPoint.p));
                 targetVisibility = earthEclipsed ? "EARTH ECLIPSED" : targetShadow;
@@ -2606,40 +2529,6 @@ const assembleWaterfallRows = (satEphems) => {
     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.
@@ -3436,18 +3325,6 @@ 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,