fix: resolve 12 CI test failures in date_range, to_timedelta, interval, explode, and sample

Agent-Logs-Url: https://github.com/githubnext/tsessebe/sessions/29d9c670-7033-40c6-baa5-3f651bf0be32

Co-authored-by: mrjf <180956+mrjf@users.noreply.github.com>

Author: Copilot

src/stats/date_range.ts

@@ -119,10 +119,18 @@ const UNIT_NORM: Readonly<Record<string, string>> = {
 /**
  * Map a raw unit token (from the regex match) to its canonical form.
  * Returns the uppercased input unchanged if no mapping exists.
+ *
+ * NOTE: "ms" (lowercase) means milliseconds; "MS" (uppercase) means month-start.
+ * Check case-sensitive lowercase tokens BEFORE uppercasing.
  */
 function normaliseUnit(raw: string): string {
+  // Case-sensitive lowercase tokens — millisecond aliases must come first
+  // so they are not confused with "MS" (month-start) after uppercasing.
+  if (raw === "ms" || raw === "L") return "ms";
+  if (raw === "us") return "us";
+  if (raw === "ns") return "ns";
   const u = raw.toUpperCase();
-  // "MS" as a unit token means month-start, not milliseconds
+  // Tokens that are passed through unchanged (already canonical)
   if (u === "MS" || u === "QS" || u === "D" || u === "B") {
     return u;
   }
@@ -427,10 +435,58 @@ function snapToAnchor(d: Date, pf: ParsedFreq): Date {
   return d;
 }
 
+/**
+ * For calendar boundary frequencies (ME, QE, YE), if the start date does not
+ * fall exactly on a boundary, snap forward to the first boundary on or after `d`.
+ *
+ * For boundary-start frequencies (MS, QS, YS), a start that already lies on a
+ * boundary is included as-is; if it is not on a boundary we snap to the next one.
+ */
+function snapToCalendarBoundary(d: Date, unit: string): Date {
+  const y = d.getUTCFullYear();
+  const m = d.getUTCMonth();
+  const day = d.getUTCDate();
+  switch (unit) {
+    case "MS":
+      // If not already month-start, advance to first day of next month.
+      if (day === 1) return d;
+      return new Date(Date.UTC(y, m + 1, 1));
+    case "ME": {
+      // If not already month-end, snap to end of the current month.
+      const lastDay = daysInMonth(y, m);
+      if (day === lastDay) return d;
+      return new Date(Date.UTC(y, m, lastDay));
+    }
+    case "QS": {
+      // Quarter-starts are Jan/Apr/Jul/Oct 1.
+      const isQS = (m === 0 || m === 3 || m === 6 || m === 9) && day === 1;
+      if (isQS) return d;
+      return nextQStart(d);
+    }
+    case "QE": {
+      // Quarter-ends are Mar 31, Jun 30, Sep 30, Dec 31.
+      const isQE = (m === 2 || m === 5 || m === 8 || m === 11) && day === daysInMonth(y, m);
+      if (isQE) return d;
+      return nextQEnd(d);
+    }
+    case "YS":
+      // Year-start is Jan 1.
+      if (m === 0 && day === 1) return d;
+      return new Date(Date.UTC(y + 1, 0, 1));
+    case "YE":
+      // Year-end is Dec 31.
+      if (m === 11 && day === 31) return d;
+      return new Date(Date.UTC(y, 11, 31));
+    default:
+      return d;
+  }
+}
+
 /** Generate `count` dates starting from `start`, advancing by `pf` each step. */
 function genFromStart(start: Date, count: number, pf: ParsedFreq): Date[] {
   const out: Date[] = [];
   let cur = snapToAnchor(start, pf);
+  cur = snapToCalendarBoundary(cur, pf.unit);
   for (let i = 0; i < count; i++) {
     out.push(cur);
     cur = advanceDate(cur, pf);

src/stats/explode.ts

@@ -175,7 +175,7 @@ export function explodeDataFrame(
   // Validate column names
   for (const c of colNames) {
     if (!df.has(c)) {
-      throw new Error(`Column "${c}" not found in DataFrame`);
+      throw new Error(`Column '${c}' not found`);
     }
   }
 
@@ -219,23 +219,30 @@ export function explodeDataFrame(
   const explodedCols = new Map<string, Scalar[]>();
   explodedCols.set(firstCol, firstOut);
 
+  // Compute per-row output count from the primary column explosion.
+  const rowCounts: number[] = new Array<number>(nRows).fill(0);
+  for (const p of firstPos) {
+    rowCounts[p] = (rowCounts[p] ?? 0) + 1;
+  }
+
   for (let ci = 1; ci < colNames.length; ci++) {
     const cname = colNames[ci] as string;
     const wideColVals: readonly unknown[] = df.col(cname).values;
     const out: Scalar[] = [];
 
     for (let row = 0; row < nRows; row++) {
       const v = wideColVals[row];
+      const expectedCount = rowCounts[row] ?? 1;
       if (isListLike(v)) {
-        if (v.length === 0) {
-          out.push(null);
-        } else {
-          for (const item of v) {
-            out.push(item as Scalar);
-          }
+        // Push items, padding with null if the list is shorter than expected.
+        for (let k = 0; k < expectedCount; k++) {
+          out.push(k < v.length ? (v[k] as Scalar) : null);
         }
       } else {
-        out.push(v as Scalar);
+        // Scalar: repeat (or pad) to fill the expected slot count.
+        for (let k = 0; k < expectedCount; k++) {
+          out.push(v as Scalar);
+        }
       }
     }
     explodedCols.set(cname, out);

src/stats/sample.ts

@@ -102,8 +102,18 @@ class Rng {
   private _state: number;
 
   constructor(seed: number) {
-    // Ensure non-zero starting state.
-    this._state = seed >>> 0 || 0xdeadbeef;
+    // Mix the seed so that small sequential seeds (0, 1, 2, …) produce
+    // well-distributed starting states.  Without mixing, XOR-shift produces
+    // near-zero outputs for seeds like 1, 2, 3 because the internal state
+    // stays small for the first few steps.
+    let s = seed >>> 0 || 0xdeadbeef;
+    // Wang hash to spread bits before the first step.
+    s = ((s ^ 61) ^ (s >>> 16)) >>> 0;
+    s = (s + (s << 3)) >>> 0;
+    s = (s ^ (s >>> 4)) >>> 0;
+    s = (Math.imul(s, 0x27d4eb2d)) >>> 0;
+    s = (s ^ (s >>> 15)) >>> 0;
+    this._state = s || 0xdeadbeef;
   }
 
   /** Returns a float in [0, 1). */

src/stats/to_timedelta.ts

@@ -30,7 +30,7 @@ const RE_ISO =
 
 /** Human unit tokens for scanAll: "1h", "30 minutes", "2.5s" etc. */
 const RE_HUMAN_UNIT =
-  /(\d+(?:\.\d+)?)\s*(weeks?|w|days?|d|hours?|h|minutes?|mins?|m|seconds?|secs?|s|milliseconds?|millis?|ms|microseconds?|micros?|us|nanoseconds?|nanos?|ns)/gi;
+  /(\d+(?:\.\d+)?)\s*(weeks?|w|days?|d|hours?|h|milliseconds?|millis?|ms|minutes?|mins?|m|seconds?|secs?|s|microseconds?|micros?|us|nanoseconds?|nanos?|ns)/gi;
 
 /** Pure integer string (no decimal). */
 const RE_INT = /^-?\d+$/;

tests/core/sample.test.ts

@@ -31,7 +31,7 @@ describe("sampleSeries", () => {
   test("replace=false: no repeated items (small pool)", () => {
     const s = new Series({ data: [10, 20, 30] });
     const r = sampleSeries(s, { n: 3, replace: false, randomState: 42 });
-    const vals = r.values as number[];
+    const vals = [...r.values] as number[];
     expect(new Set(vals).size).toBe(3);
     expect(vals.sort((a, b) => a - b)).toEqual([10, 20, 30]);
   });

tests/stats/date_range.test.ts

@@ -326,7 +326,7 @@ describe("dateRange — QS", () => {
     const r = dateRange({ start: "2024-01-01", periods: 4, freq: "QS" });
     expect(r).toHaveLength(4);
     const months = r.map((d) => d.getUTCMonth() + 1);
-    expect(months).toStrictEqual([4, 7, 10, 1]); // Apr Jul Oct Jan
+    expect(months).toStrictEqual([1, 4, 7, 10]); // Jan Apr Jul Oct
   });
 
   it("QE: generates 4 quarter-ends", () => {
@@ -345,7 +345,7 @@ describe("dateRange — YS/YE", () => {
     const r = dateRange({ start: "2024-01-01", periods: 3, freq: "YS" });
     expect(r).toHaveLength(3);
     const years = r.map((d) => d.getUTCFullYear());
-    expect(years).toStrictEqual([2025, 2026, 2027]);
+    expect(years).toStrictEqual([2024, 2025, 2026]);
   });
 
   it("YE generates Dec 31 for each year", () => {

tests/stats/explode.test.ts

@@ -211,7 +211,7 @@ describe("explodeDataFrame", () => {
 
   test("throws on unknown column", () => {
     const df = DataFrame.fromColumns({ a: [[1, 2]] as unknown as Scalar[] });
-    expect(() => explodeDataFrame(df, "z")).toThrow(/Column "z" not found/);
+    expect(() => explodeDataFrame(df, "z")).toThrow(/Column 'z' not found/);
   });
 
   test("empty DataFrame returns empty DataFrame", () => {

tests/stats/interval.test.ts

@@ -142,9 +142,8 @@ describe("Interval", () => {
     test("touching endpoints — one open side", () => {
       const a = new Interval(0, 2, "right");
       const b = new Interval(2, 4, "left");
-      expect(a.overlaps(b)).toBe(false); // a's right is closed, b's left is closed — but they touch at 2
-      // Actually both touch: a closes at right (2], b opens at left [2 — same point
-      // corrected: both include 2 → they do overlap
+      // a = (0, 2] closes on 2; b = [2, 4) opens on 2 — both include 2, so they overlap.
+      expect(a.overlaps(b)).toBe(true);
     });
 
     test("completely disjoint", () => {
@@ -421,14 +420,18 @@ describe("intervalRange", () => {
 describe("Interval properties (fast-check)", () => {
   test("contains is symmetric within interior", () => {
     fc.assert(
-      fc.property(fc.float({ min: -100, max: 100 }), fc.float({ min: -100, max: 100 }), (a, b) => {
-        if (a > b) {
-          return true; // skip invalid
-        }
-        const iv = new Interval(a, b, "both");
-        const mid = (a + b) / 2;
-        return iv.contains(mid);
-      }),
+      fc.property(
+        fc.float({ min: -100, max: 100, noNaN: true }),
+        fc.float({ min: -100, max: 100, noNaN: true }),
+        (a, b) => {
+          if (a > b) {
+            return true; // skip invalid
+          }
+          const iv = new Interval(a, b, "both");
+          const mid = (a + b) / 2;
+          return iv.contains(mid);
+        },
+      ),
     );
   });