fix: resolve all TypeScript strict-mode errors across source and test files

Source fixes:
- src/core/reindex.ts: add undefined guards for noUncheckedIndexedAccess
- src/core/timestamp.ts: guard regex match group against undefined
- src/io/json_normalize.ts: use Dtype.float64/int64/bool/object statics,
  fix Series/DataFrame constructors, convert Record to Map
- src/stats/combine_first.ts: replace hasColumn() with has()
- src/stats/crosstab.ts: fix bucket array init and margin arithmetic types
- src/stats/factorize.ts: use null instead of undefined for Series name
- src/stats/isin.ts: use string|symbol index type for Symbol.iterator check
- src/stats/memory_usage.ts: use df.items() instead of for-of on DataFrame
- src/stats/clip_with_bounds.ts: add DataFrameBoundArg type for DataFrame bounds
- src/groupby/groupby.ts: implement aggNamed() method on DataFrameGroupBy

Test fixes:
- Cast toArray() results to (number|null)[] for null-containing assertions
- Replace Index .length with .size
- Add non-null assertions for indexed access
- Use DataFrame.fromColumns or proper Map constructor
- Fix type annotations for property-based tests
- Use identity comparison pattern for toBe with union types

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

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

Author: Copilot

src/core/reindex.ts

@@ -198,7 +198,7 @@ function applyNearest(values: Scalar[], present: readonly boolean[]): Scalar[] {
       out[i] = rightVal[i];
     } else if (rd === -1) {
       out[i] = leftVal[i];
-    } else if (rd <= ld) {
+    } else if (rd !== undefined && ld !== undefined && rd <= ld) {
       // prefer right on tie
       out[i] = rightVal[i];
     } else {
@@ -268,7 +268,10 @@ export function reindexSeries<T extends Scalar>(
     const key = String(newLabels[i]);
     const positions = labelMap.get(key);
     if (positions !== undefined && positions.length > 0) {
-      resultValues[i] = series.values[positions[0]] as Scalar;
+      const pos0 = positions[0];
+      if (pos0 !== undefined) {
+        resultValues[i] = series.values[pos0] as Scalar;
+      }
       present[i] = true;
     }
   }

src/core/timestamp.ts

@@ -331,7 +331,7 @@ function freqMs(freq: string): number {
   if (upper === "D") return MS_PER_DAY;
   // Try "Nunit" pattern (e.g. "2H", "15T").
   const m = /^(\d+)(.+)$/.exec(freq);
-  if (m !== null) {
+  if (m !== null && m[2] !== undefined) {
     return Number(m[1]) * freqMs(m[2]);
   }
   throw new Error(`Timestamp.floor/ceil/round: unsupported frequency "${freq}"`);

src/groupby/groupby.ts

@@ -21,6 +21,7 @@ import { RangeIndex } from "../core/index.ts";
 import { DataFrame } from "../core/index.ts";
 import { Series } from "../core/index.ts";
 import type { Label, Scalar } from "../types.ts";
+import type { NamedAggSpec } from "./named_agg.ts";
 
 // ─── types ────────────────────────────────────────────────────────────────────
 
@@ -304,6 +305,61 @@ export class DataFrameGroupBy {
     return this._runAgg(colSpecs, asIndex);
   }
 
+  /**
+   * Aggregate with named output columns via `NamedAgg` specs.
+   *
+   * Each key in `spec` becomes an output column name.  The corresponding
+   * `NamedAgg` tells which source column to read and which aggregation to apply.
+   *
+   * @example
+   * ```ts
+   * df.groupby("dept").aggNamed({
+   *   total: namedAgg("salary", "sum"),
+   *   avg:   namedAgg("salary", "mean"),
+   * });
+   * ```
+   */
+  aggNamed(spec: NamedAggSpec, asIndex = true): DataFrame {
+    const groupKeys = this._groups.map((g) => g.key);
+    const resultCols: Record<string, Scalar[]> = {};
+
+    if (!asIndex) {
+      if (this._by.length === 1) {
+        const byCol = this._by[0] as string;
+        resultCols[byCol] = groupKeys.slice();
+      } else {
+        for (const by of this._by) {
+          resultCols[by] = [];
+        }
+        for (const g of this._groups) {
+          const parts = (g.key as string).split("__SEP__");
+          this._by.forEach((by, idx) => {
+            const byArr = resultCols[by];
+            if (byArr !== undefined) {
+              byArr.push(parts[idx] ?? null);
+            }
+          });
+        }
+      }
+    }
+
+    for (const [outputCol, namedSpec] of Object.entries(spec)) {
+      const srcVals = this._df.col(namedSpec.column).values as readonly Scalar[];
+      const fn = resolveAgg(namedSpec.aggfunc);
+      resultCols[outputCol] = this._groups.map((g) =>
+        fn(g.positions.map((p) => srcVals[p] as Scalar)),
+      );
+    }
+
+    const rowIdx: Index<Label> = asIndex
+      ? new Index<Label>(groupKeys)
+      : defaultIndex(groupKeys.length);
+
+    return DataFrame.fromColumns(resultCols as Record<string, readonly Scalar[]>, {
+      index: rowIdx,
+    });
+  }
+
   /** Shorthand for `agg("sum")` — numeric columns only, like pandas. */
   sum(): DataFrame {
     const cols = this._numericValueCols();

src/io/json_normalize.ts

@@ -310,6 +310,7 @@ export function jsonNormalize(
     let currentRecords: readonly JsonObject[] = records;
     for (let i = 0; i < pathList.length; i++) {
       const path = pathList[i];
+      if (path === undefined) continue;
       const isFinal = i === pathList.length - 1;
       if (isFinal) {
         rows = normalizeWithPath(
@@ -343,7 +344,7 @@ export function jsonNormalize(
 
   // ── Build column sets and DataFrame ───────────────────────────────────────
   if (rows.length === 0) {
-    return new DataFrame({});
+    return DataFrame.fromColumns({});
   }
 
   // Union of all column names (preserve first-seen insertion order)
@@ -364,22 +365,20 @@ export function jsonNormalize(
   }
 
   // Build Series columns and infer dtypes
-  const seriesMap: Record<string, Series> = {};
+  const colMap = new Map<string, Series<Scalar>>();
   for (const [col, vals] of Object.entries(colData)) {
     let dtype: Dtype;
     if (vals.every((v) => v === null || typeof v === "number")) {
       dtype = vals.some((v) => v !== null && !Number.isInteger(v))
-        ? new Dtype("float64")
-        : new Dtype("int64");
+        ? Dtype.float64
+        : Dtype.int64;
     } else if (vals.every((v) => v === null || typeof v === "boolean")) {
-      dtype = new Dtype("bool");
+      dtype = Dtype.bool;
     } else {
-      dtype = new Dtype("object");
+      dtype = Dtype.object;
     }
-    seriesMap[col] = new Series(vals, { name: col, dtype });
+    colMap.set(col, new Series({ data: vals, name: col, dtype }));
   }
 
-  return new DataFrame(seriesMap, {
-    index: new RangeIndex(rows.length),
-  });
+  return new DataFrame(colMap, new RangeIndex(rows.length));
 }

src/stats/clip_with_bounds.ts

@@ -39,8 +39,15 @@ export interface SeriesClipBoundsOptions {
   readonly upper?: BoundArg;
 }
 
+/** A bound that also accepts a DataFrame (for element-wise clipping). */
+export type DataFrameBoundArg = BoundArg | DataFrame;
+
 /** Options for {@link clipDataFrameWithBounds}. */
-export interface DataFrameClipBoundsOptions extends SeriesClipBoundsOptions {
+export interface DataFrameClipBoundsOptions {
+  /** Lower bound. May be any `BoundArg` or a `DataFrame` for element-wise clipping. */
+  readonly lower?: DataFrameBoundArg;
+  /** Upper bound. May be any `BoundArg` or a `DataFrame` for element-wise clipping. */
+  readonly upper?: DataFrameBoundArg;
   /**
    * Axis along which a Series bound is broadcast:
    * - `0` / `"index"` (default): Series is indexed on **row labels** — each row

src/stats/combine_first.ts

@@ -149,8 +149,8 @@ export function combineFirstDataFrame(self: DataFrame, other: DataFrame): DataFr
   const resultColMap = new Map<string, Series<Scalar>>();
 
   for (const colName of unionCols) {
-    const selfHasCol = self.hasColumn(colName);
-    const otherHasCol = other.hasColumn(colName);
+    const selfHasCol = self.has(colName);
+    const otherHasCol = other.has(colName);
 
     const data: Scalar[] = [];
 

src/stats/crosstab.ts

@@ -201,8 +201,8 @@ export function crosstab(
   // buckets[r][c] = collected numeric values for aggregation (when values+aggfunc provided).
   const buckets: Array<Array<number[] | undefined>> | null =
     values !== undefined
-      ? Array.from({ length: nRows }, () =>
-          Array.from<number[] | undefined>({ length: nCols }, () => undefined),
+      ? Array.from({ length: nRows }, (): Array<number[] | undefined> =>
+          new Array<number[] | undefined>(nCols).fill(undefined),
         )
       : null;
 
@@ -293,12 +293,12 @@ export function crosstab(
       const name = labelStr(colUniques[ci] as Scalar);
       const col = colData[name];
       if (col !== undefined) {
-        col.push(col.reduce((s, v) => s + (v as number), 0));
+        col.push(col.reduce((s: number, v) => s + (typeof v === "number" ? v : 0), 0));
       }
     }
     // Add an "All" column with row totals (and grand total in the last cell).
     const allCol: Scalar[] = cells.map((row) => row.reduce((s, v) => s + v, 0));
-    allCol.push(allCol.reduce((s, v) => s + (v as number), 0));
+    allCol.push(allCol.reduce((s: number, v) => s + (typeof v === "number" ? v : 0), 0));
     colData[marginsName] = allCol;
     finalRowLabels = [...rowLabels, marginsName as Label];
   }

src/stats/factorize.ts

@@ -193,7 +193,7 @@ export function seriesFactorize<T extends Scalar>(
   const codesSeries = new Series<number>({
     data: result.codes as number[],
     index: codesIndex,
-    name: series.name ?? undefined,
+    name: series.name ?? null,
   });
   const uniquesSeries = new Series<T>({
     data: result.uniques as T[],

src/stats/isin.ts

@@ -91,7 +91,7 @@ function isIsinDict(obj: DataFrameIsinValues): obj is IsinDict {
     typeof obj === "object" &&
     !Array.isArray(obj) &&
     !(obj instanceof Set) &&
-    typeof (obj as Record<string, unknown>)[Symbol.iterator] !== "function"
+    typeof (obj as Record<string | symbol, unknown>)[Symbol.iterator] !== "function"
   );
 }
 

src/stats/memory_usage.ts

@@ -176,11 +176,11 @@ export function dataFrameMemoryUsage(
     values.push(indexMemoryBytes(df.index, deep));
   }
 
-  for (const [colName, col] of df) {
+  for (const [colName, col] of df.items()) {
     names.push(colName);
     let mem: number;
     if (deep) {
-      mem = col.values.reduce((sum: number, v) => sum + deepScalarSize(v), 0);
+      mem = col.values.reduce((sum: number, v: Scalar) => sum + deepScalarSize(v), 0);
     } else {
       mem = col.size * shallowElemSize(col.dtype.itemsize);
     }