diff --git a/benchmarks/pandas/bench_between.py b/benchmarks/pandas/bench_between.py
new file mode 100644
index 00000000..7ddfd202
--- /dev/null
+++ b/benchmarks/pandas/bench_between.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.between() — element-wise range check."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.between(25000.0, 75000.0)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.between(25000.0, 75000.0)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"between","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_clip.py b/benchmarks/pandas/bench_clip.py
new file mode 100644
index 00000000..30be9d0b
--- /dev/null
+++ b/benchmarks/pandas/bench_clip.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.clip() — clip values to a range."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.clip(lower=10000.0, upper=90000.0)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.clip(lower=10000.0, upper=90000.0)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"clip","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_corr.py b/benchmarks/pandas/bench_corr.py
new file mode 100644
index 00000000..fde4e7c3
--- /dev/null
+++ b/benchmarks/pandas/bench_corr.py
@@ -0,0 +1,21 @@
+"""Benchmark: DataFrame.corr — pairwise correlation of numeric columns."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[float(i*1.1) for i in range(SIZE)],"b":[float(i*0.7+0.3) for i in range(SIZE)],"c":[float(i*-0.5+100) for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.corr()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.corr()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"corr","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_cov.py b/benchmarks/pandas/bench_cov.py
new file mode 100644
index 00000000..95e9c5c3
--- /dev/null
+++ b/benchmarks/pandas/bench_cov.py
@@ -0,0 +1,21 @@
+"""Benchmark: DataFrame.cov — pairwise covariance of numeric columns."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[float(i*1.1) for i in range(SIZE)],"b":[float(i*0.7+0.3) for i in range(SIZE)],"c":[float(i*-0.5+100) for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.cov()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.cov()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"cov","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_crosstab.py b/benchmarks/pandas/bench_crosstab.py
new file mode 100644
index 00000000..10237533
--- /dev/null
+++ b/benchmarks/pandas/bench_crosstab.py
@@ -0,0 +1,24 @@
+"""Benchmark: pd.crosstab() — compute a cross-tabulation."""
+import json, time
+import pandas as pd
+
+SIZE = 50_000
+WARMUP = 5
+ITERATIONS = 50
+
+import random
+random.seed(42)
+a = pd.Series([random.choice(["x","y","z"]) for _ in range(SIZE)])
+b = pd.Series([random.choice(["p","q","r","s"]) for _ in range(SIZE)])
+
+for _ in range(WARMUP):
+    pd.crosstab(a, b)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.crosstab(a, b)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"crosstab","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_cut.py b/benchmarks/pandas/bench_cut.py
new file mode 100644
index 00000000..b6254397
--- /dev/null
+++ b/benchmarks/pandas/bench_cut.py
@@ -0,0 +1,21 @@
+"""Benchmark: pd.cut() — bin a Series into discrete intervals."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    pd.cut(s, bins=10)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.cut(s, bins=10)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"cut","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_dataframe_astype.py b/benchmarks/pandas/bench_dataframe_astype.py
new file mode 100644
index 00000000..f2f685f0
--- /dev/null
+++ b/benchmarks/pandas/bench_dataframe_astype.py
@@ -0,0 +1,21 @@
+"""Benchmark: DataFrame.astype() — cast column dtypes."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[float(i) for i in range(SIZE)],"b":[i for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.astype({"a": "float32", "b": "int32"})
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.astype({"a": "float32", "b": "int32"})
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"dataframe_astype","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_dataframe_head_tail.py b/benchmarks/pandas/bench_dataframe_head_tail.py
new file mode 100644
index 00000000..7f7891f6
--- /dev/null
+++ b/benchmarks/pandas/bench_dataframe_head_tail.py
@@ -0,0 +1,23 @@
+"""Benchmark: DataFrame.head() and .tail() — slice first/last N rows."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[float(i) for i in range(SIZE)],"b":[i*2 for i in range(SIZE)],"c":[str(i) for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.head(100)
+    df.tail(100)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.head(100)
+    df.tail(100)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"dataframe_head_tail","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_diff.py b/benchmarks/pandas/bench_diff.py
new file mode 100644
index 00000000..72ff53a5
--- /dev/null
+++ b/benchmarks/pandas/bench_diff.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.diff() — first discrete difference."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i*1.1+0.5) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.diff()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.diff()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"diff","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_drop_duplicates.py b/benchmarks/pandas/bench_drop_duplicates.py
new file mode 100644
index 00000000..eafc3158
--- /dev/null
+++ b/benchmarks/pandas/bench_drop_duplicates.py
@@ -0,0 +1,21 @@
+"""Benchmark: DataFrame.drop_duplicates() — remove duplicate rows."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[i % 1000 for i in range(SIZE)],"b":[i % 500 for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.drop_duplicates()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.drop_duplicates()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"drop_duplicates","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_duplicated.py b/benchmarks/pandas/bench_duplicated.py
new file mode 100644
index 00000000..e5eb52d3
--- /dev/null
+++ b/benchmarks/pandas/bench_duplicated.py
@@ -0,0 +1,21 @@
+"""Benchmark: DataFrame.duplicated() — detect duplicate rows."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({"a":[i % 1000 for i in range(SIZE)],"b":[i % 500 for i in range(SIZE)]})
+
+for _ in range(WARMUP):
+    df.duplicated()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.duplicated()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"duplicated","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_expanding_mean.py b/benchmarks/pandas/bench_expanding_mean.py
new file mode 100644
index 00000000..7effcf51
--- /dev/null
+++ b/benchmarks/pandas/bench_expanding_mean.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.expanding().mean() — expanding window mean."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i*1.1+0.5) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.expanding().mean()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.expanding().mean()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"expanding_mean","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_interpolate.py b/benchmarks/pandas/bench_interpolate.py
new file mode 100644
index 00000000..ab3e81d9
--- /dev/null
+++ b/benchmarks/pandas/bench_interpolate.py
@@ -0,0 +1,23 @@
+"""Benchmark: Series.interpolate() — linear interpolation over NaN values."""
+import json, time
+import pandas as pd
+import math
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+data = [float(i) if i % 5 != 0 else math.nan for i in range(SIZE)]
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.interpolate(method="linear")
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.interpolate(method="linear")
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"interpolate","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_isin.py b/benchmarks/pandas/bench_isin.py
new file mode 100644
index 00000000..6340ccb8
--- /dev/null
+++ b/benchmarks/pandas/bench_isin.py
@@ -0,0 +1,22 @@
+"""Benchmark: Series.isin() — membership test."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([i % 5000 for i in range(SIZE)])
+test_set = list(range(0, 2500))
+
+for _ in range(WARMUP):
+    s.isin(test_set)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.isin(test_set)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"isin","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_melt.py b/benchmarks/pandas/bench_melt.py
new file mode 100644
index 00000000..b01c66d1
--- /dev/null
+++ b/benchmarks/pandas/bench_melt.py
@@ -0,0 +1,23 @@
+"""Benchmark: DataFrame.melt — unpivots wide-format DataFrame to long-format."""
+import json, time
+import pandas as pd
+
+SIZE = 10_000
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({f"col{i}": [float(j*i+0.5) for j in range(SIZE)] for i in range(1, 6)})
+id_vars = ["col1"]
+value_vars = ["col2", "col3", "col4", "col5"]
+
+for _ in range(WARMUP):
+    df.melt(id_vars=id_vars, value_vars=value_vars)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.melt(id_vars=id_vars, value_vars=value_vars)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"melt","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_nlargest.py b/benchmarks/pandas/bench_nlargest.py
new file mode 100644
index 00000000..d02e1145
--- /dev/null
+++ b/benchmarks/pandas/bench_nlargest.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.nlargest() — get the n largest values."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i*1.1+0.5) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.nlargest(100)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.nlargest(100)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"nlargest","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_pct_change.py b/benchmarks/pandas/bench_pct_change.py
new file mode 100644
index 00000000..70673422
--- /dev/null
+++ b/benchmarks/pandas/bench_pct_change.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.pct_change() — percentage change between elements."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i*1.1+1.0) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.pct_change()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.pct_change()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"pct_change","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_qcut.py b/benchmarks/pandas/bench_qcut.py
new file mode 100644
index 00000000..ad958a17
--- /dev/null
+++ b/benchmarks/pandas/bench_qcut.py
@@ -0,0 +1,21 @@
+"""Benchmark: pd.qcut() — quantile-based binning."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    pd.qcut(s, q=10)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    pd.qcut(s, q=10)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"qcut","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_rank.py b/benchmarks/pandas/bench_rank.py
new file mode 100644
index 00000000..11f3cb78
--- /dev/null
+++ b/benchmarks/pandas/bench_rank.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.rank() — rank values with average tie-breaking."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i % 1000) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.rank()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.rank()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"rank","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_rolling_std.py b/benchmarks/pandas/bench_rolling_std.py
new file mode 100644
index 00000000..88522698
--- /dev/null
+++ b/benchmarks/pandas/bench_rolling_std.py
@@ -0,0 +1,22 @@
+"""Benchmark: Series.rolling().std() — rolling standard deviation."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WINDOW = 20
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i*1.1+0.5) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.rolling(WINDOW).std()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.rolling(WINDOW).std()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"rolling_std","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_series_abs.py b/benchmarks/pandas/bench_series_abs.py
new file mode 100644
index 00000000..9d1163f0
--- /dev/null
+++ b/benchmarks/pandas/bench_series_abs.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.abs() — element-wise absolute value."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i - 50000) for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.abs()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.abs()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"series_abs","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_series_map.py b/benchmarks/pandas/bench_series_map.py
new file mode 100644
index 00000000..c7ffd0ff
--- /dev/null
+++ b/benchmarks/pandas/bench_series_map.py
@@ -0,0 +1,22 @@
+"""Benchmark: Series.map() with a dictionary lookup."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([i % 1000 for i in range(SIZE)])
+lookup = {i: float(i * 2.5) for i in range(1000)}
+
+for _ in range(WARMUP):
+    s.map(lookup)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.map(lookup)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"series_map","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_series_nunique.py b/benchmarks/pandas/bench_series_nunique.py
new file mode 100644
index 00000000..db67b43c
--- /dev/null
+++ b/benchmarks/pandas/bench_series_nunique.py
@@ -0,0 +1,21 @@
+"""Benchmark: Series.nunique() — count unique values."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([i % 1000 for i in range(SIZE)])
+
+for _ in range(WARMUP):
+    s.nunique()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.nunique()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"series_nunique","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_stack.py b/benchmarks/pandas/bench_stack.py
new file mode 100644
index 00000000..4a9b4b87
--- /dev/null
+++ b/benchmarks/pandas/bench_stack.py
@@ -0,0 +1,22 @@
+"""Benchmark: DataFrame.stack() — pivot innermost column level to row index."""
+import json, time
+import pandas as pd
+
+ROWS = 1_000
+COLS = 20
+WARMUP = 5
+ITERATIONS = 50
+
+df = pd.DataFrame({f"c{j}": [float(i*j+0.5) for i in range(ROWS)] for j in range(1, COLS+1)})
+
+for _ in range(WARMUP):
+    df.stack()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    df.stack()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"stack","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_unstack.py b/benchmarks/pandas/bench_unstack.py
new file mode 100644
index 00000000..4b2dca2a
--- /dev/null
+++ b/benchmarks/pandas/bench_unstack.py
@@ -0,0 +1,24 @@
+"""Benchmark: DataFrame.unstack() — pivot innermost index level to columns."""
+import json, time
+import pandas as pd
+
+ROWS = 500
+COLS = 10
+WARMUP = 5
+ITERATIONS = 50
+
+import numpy as np
+idx = pd.MultiIndex.from_product([range(ROWS), range(COLS)], names=["row","col"])
+s = pd.Series([float(i) for i in range(ROWS * COLS)], index=idx)
+
+for _ in range(WARMUP):
+    s.unstack()
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.unstack()
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"unstack","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/pandas/bench_where.py b/benchmarks/pandas/bench_where.py
new file mode 100644
index 00000000..096f6b48
--- /dev/null
+++ b/benchmarks/pandas/bench_where.py
@@ -0,0 +1,22 @@
+"""Benchmark: Series.where() — conditional replacement."""
+import json, time
+import pandas as pd
+
+SIZE = 100_000
+WARMUP = 5
+ITERATIONS = 50
+
+s = pd.Series([float(i) for i in range(SIZE)])
+cond = s > 50000.0
+
+for _ in range(WARMUP):
+    s.where(cond, other=0.0)
+
+times = []
+for _ in range(ITERATIONS):
+    t0 = time.perf_counter()
+    s.where(cond, other=0.0)
+    times.append((time.perf_counter() - t0) * 1000)
+
+total_ms = sum(times)
+print(json.dumps({"function":"where","mean_ms":round(total_ms/ITERATIONS,3),"iterations":ITERATIONS,"total_ms":round(total_ms,3)}))
diff --git a/benchmarks/results.json b/benchmarks/results.json
index c883f334..17a01c1c 100644
--- a/benchmarks/results.json
+++ b/benchmarks/results.json
@@ -1,5 +1,27 @@
 {
   "benchmarks": [
+    {
+      "function": "between",
+      "tsb": null,
+      "pandas": {
+        "function": "between",
+        "mean_ms": 0.115,
+        "iterations": 50,
+        "total_ms": 5.771
+      },
+      "ratio": null
+    },
+    {
+      "function": "clip",
+      "tsb": null,
+      "pandas": {
+        "function": "clip",
+        "mean_ms": 0.706,
+        "iterations": 50,
+        "total_ms": 35.277
+      },
+      "ratio": null
+    },
     {
       "function": "concat",
       "tsb": null,
@@ -11,6 +33,50 @@
       },
       "ratio": null
     },
+    {
+      "function": "corr",
+      "tsb": null,
+      "pandas": {
+        "function": "corr",
+        "mean_ms": 0.29,
+        "iterations": 50,
+        "total_ms": 14.512
+      },
+      "ratio": null
+    },
+    {
+      "function": "cov",
+      "tsb": null,
+      "pandas": {
+        "function": "cov",
+        "mean_ms": 0.221,
+        "iterations": 50,
+        "total_ms": 11.046
+      },
+      "ratio": null
+    },
+    {
+      "function": "crosstab",
+      "tsb": null,
+      "pandas": {
+        "function": "crosstab",
+        "mean_ms": 12.885,
+        "iterations": 50,
+        "total_ms": 644.272
+      },
+      "ratio": null
+    },
+    {
+      "function": "cut",
+      "tsb": null,
+      "pandas": {
+        "function": "cut",
+        "mean_ms": 1.459,
+        "iterations": 50,
+        "total_ms": 72.96
+      },
+      "ratio": null
+    },
     {
       "function": "dataframe_apply",
       "tsb": null,
@@ -22,6 +88,17 @@
       },
       "ratio": null
     },
+    {
+      "function": "dataframe_astype",
+      "tsb": null,
+      "pandas": {
+        "function": "dataframe_astype",
+        "mean_ms": 0.509,
+        "iterations": 50,
+        "total_ms": 25.454
+      },
+      "ratio": null
+    },
     {
       "function": "dataframe_creation",
       "tsb": null,
@@ -55,6 +132,17 @@
       },
       "ratio": null
     },
+    {
+      "function": "dataframe_head_tail",
+      "tsb": null,
+      "pandas": {
+        "function": "dataframe_head_tail",
+        "mean_ms": 0.059,
+        "iterations": 50,
+        "total_ms": 2.925
+      },
+      "ratio": null
+    },
     {
       "function": "dataframe_rename",
       "tsb": null,
@@ -88,6 +176,39 @@
       },
       "ratio": null
     },
+    {
+      "function": "diff",
+      "tsb": null,
+      "pandas": {
+        "function": "diff",
+        "mean_ms": 0.143,
+        "iterations": 50,
+        "total_ms": 7.175
+      },
+      "ratio": null
+    },
+    {
+      "function": "drop_duplicates",
+      "tsb": null,
+      "pandas": {
+        "function": "drop_duplicates",
+        "mean_ms": 3.303,
+        "iterations": 50,
+        "total_ms": 165.161
+      },
+      "ratio": null
+    },
+    {
+      "function": "duplicated",
+      "tsb": null,
+      "pandas": {
+        "function": "duplicated",
+        "mean_ms": 3.22,
+        "iterations": 50,
+        "total_ms": 160.983
+      },
+      "ratio": null
+    },
     {
       "function": "ewm_mean",
       "tsb": null,
@@ -99,6 +220,17 @@
       },
       "ratio": null
     },
+    {
+      "function": "expanding_mean",
+      "tsb": null,
+      "pandas": {
+        "function": "expanding_mean",
+        "mean_ms": 1.11,
+        "iterations": 50,
+        "total_ms": 55.505
+      },
+      "ratio": null
+    },
     {
       "function": "groupby_mean",
       "tsb": null,
@@ -110,6 +242,39 @@
       },
       "ratio": null
     },
+    {
+      "function": "interpolate",
+      "tsb": null,
+      "pandas": {
+        "function": "interpolate",
+        "mean_ms": 3.356,
+        "iterations": 50,
+        "total_ms": 167.813
+      },
+      "ratio": null
+    },
+    {
+      "function": "isin",
+      "tsb": null,
+      "pandas": {
+        "function": "isin",
+        "mean_ms": 0.673,
+        "iterations": 50,
+        "total_ms": 33.666
+      },
+      "ratio": null
+    },
+    {
+      "function": "melt",
+      "tsb": null,
+      "pandas": {
+        "function": "melt",
+        "mean_ms": 2.551,
+        "iterations": 50,
+        "total_ms": 127.542
+      },
+      "ratio": null
+    },
     {
       "function": "merge",
       "tsb": null,
@@ -121,6 +286,28 @@
       },
       "ratio": null
     },
+    {
+      "function": "nlargest",
+      "tsb": null,
+      "pandas": {
+        "function": "nlargest",
+        "mean_ms": 0.717,
+        "iterations": 50,
+        "total_ms": 35.865
+      },
+      "ratio": null
+    },
+    {
+      "function": "pct_change",
+      "tsb": null,
+      "pandas": {
+        "function": "pct_change",
+        "mean_ms": 0.193,
+        "iterations": 50,
+        "total_ms": 9.668
+      },
+      "ratio": null
+    },
     {
       "function": "pivot_table",
       "tsb": null,
@@ -132,6 +319,28 @@
       },
       "ratio": null
     },
+    {
+      "function": "qcut",
+      "tsb": null,
+      "pandas": {
+        "function": "qcut",
+        "mean_ms": 2.569,
+        "iterations": 50,
+        "total_ms": 128.474
+      },
+      "ratio": null
+    },
+    {
+      "function": "rank",
+      "tsb": null,
+      "pandas": {
+        "function": "rank",
+        "mean_ms": 3.057,
+        "iterations": 50,
+        "total_ms": 152.835
+      },
+      "ratio": null
+    },
     {
       "function": "read_csv",
       "tsb": null,
@@ -154,6 +363,28 @@
       },
       "ratio": null
     },
+    {
+      "function": "rolling_std",
+      "tsb": null,
+      "pandas": {
+        "function": "rolling_std",
+        "mean_ms": 3.437,
+        "iterations": 50,
+        "total_ms": 171.832
+      },
+      "ratio": null
+    },
+    {
+      "function": "series_abs",
+      "tsb": null,
+      "pandas": {
+        "function": "series_abs",
+        "mean_ms": 0.037,
+        "iterations": 50,
+        "total_ms": 1.857
+      },
+      "ratio": null
+    },
     {
       "function": "series_arithmetic",
       "tsb": null,
@@ -198,6 +429,28 @@
       },
       "ratio": null
     },
+    {
+      "function": "series_map",
+      "tsb": null,
+      "pandas": {
+        "function": "series_map",
+        "mean_ms": 0.821,
+        "iterations": 50,
+        "total_ms": 41.036
+      },
+      "ratio": null
+    },
+    {
+      "function": "series_nunique",
+      "tsb": null,
+      "pandas": {
+        "function": "series_nunique",
+        "mean_ms": 0.426,
+        "iterations": 50,
+        "total_ms": 21.3
+      },
+      "ratio": null
+    },
     {
       "function": "series_shift",
       "tsb": null,
@@ -241,7 +494,40 @@
         "total_ms": 92.12644899997713
       },
       "ratio": null
+    },
+    {
+      "function": "stack",
+      "tsb": null,
+      "pandas": {
+        "function": "stack",
+        "mean_ms": 0.337,
+        "iterations": 50,
+        "total_ms": 16.831
+      },
+      "ratio": null
+    },
+    {
+      "function": "unstack",
+      "tsb": null,
+      "pandas": {
+        "function": "unstack",
+        "mean_ms": 0.398,
+        "iterations": 50,
+        "total_ms": 19.887
+      },
+      "ratio": null
+    },
+    {
+      "function": "where",
+      "tsb": null,
+      "pandas": {
+        "function": "where",
+        "mean_ms": 0.23,
+        "iterations": 50,
+        "total_ms": 11.504
+      },
+      "ratio": null
     }
   ],
-  "timestamp": "2026-04-12T15:46:00Z"
-}
\ No newline at end of file
+  "timestamp": "2026-04-12T17:15:00Z"
+}
diff --git a/benchmarks/tsb/bench_between.ts b/benchmarks/tsb/bench_between.ts
new file mode 100644
index 00000000..4e06570c
--- /dev/null
+++ b/benchmarks/tsb/bench_between.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.between() — element-wise range check.
+ * Outputs JSON: {"function": "between", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.between(25000.0, 75000.0);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.between(25000.0, 75000.0);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "between",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_clip.ts b/benchmarks/tsb/bench_clip.ts
new file mode 100644
index 00000000..77ce3688
--- /dev/null
+++ b/benchmarks/tsb/bench_clip.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.clip() — clip values to a range.
+ * Outputs JSON: {"function": "clip", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.clip({ lower: 10000.0, upper: 90000.0 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.clip({ lower: 10000.0, upper: 90000.0 });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "clip",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_corr.ts b/benchmarks/tsb/bench_corr.ts
new file mode 100644
index 00000000..39821d71
--- /dev/null
+++ b/benchmarks/tsb/bench_corr.ts
@@ -0,0 +1,37 @@
+/**
+ * Benchmark: DataFrame.corr — pairwise correlation of numeric columns.
+ * Outputs JSON: {"function": "corr", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.1),
+  b: Array.from({ length: SIZE }, (_, i) => i * 0.7 + 0.3),
+  c: Array.from({ length: SIZE }, (_, i) => i * -0.5 + 100),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.corr();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.corr();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "corr",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_cov.ts b/benchmarks/tsb/bench_cov.ts
new file mode 100644
index 00000000..af60be69
--- /dev/null
+++ b/benchmarks/tsb/bench_cov.ts
@@ -0,0 +1,37 @@
+/**
+ * Benchmark: DataFrame.cov — pairwise covariance of numeric columns.
+ * Outputs JSON: {"function": "cov", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.1),
+  b: Array.from({ length: SIZE }, (_, i) => i * 0.7 + 0.3),
+  c: Array.from({ length: SIZE }, (_, i) => i * -0.5 + 100),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.cov();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.cov();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "cov",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_crosstab.ts b/benchmarks/tsb/bench_crosstab.ts
new file mode 100644
index 00000000..24b2fde7
--- /dev/null
+++ b/benchmarks/tsb/bench_crosstab.ts
@@ -0,0 +1,42 @@
+/**
+ * Benchmark: crosstab() — compute a cross-tabulation.
+ * Outputs JSON: {"function": "crosstab", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, crosstab } from "../../src/index.ts";
+
+const SIZE = 50_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const choices_a = ["x", "y", "z"];
+const choices_b = ["p", "q", "r", "s"];
+let seed = 42;
+function rand(): number {
+  seed = (seed * 1664525 + 1013904223) & 0x7fffffff;
+  return seed;
+}
+
+const a = new Series({ data: Array.from({ length: SIZE }, () => choices_a[rand() % 3]) });
+const b = new Series({ data: Array.from({ length: SIZE }, () => choices_b[rand() % 4]) });
+
+for (let i = 0; i < WARMUP; i++) {
+  crosstab(a, b);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  crosstab(a, b);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "crosstab",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_cut.ts b/benchmarks/tsb/bench_cut.ts
new file mode 100644
index 00000000..e205b6d4
--- /dev/null
+++ b/benchmarks/tsb/bench_cut.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: cut() — bin a Series into discrete intervals.
+ * Outputs JSON: {"function": "cut", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, cut } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  cut(s, { bins: 10 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  cut(s, { bins: 10 });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "cut",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_dataframe_apply.ts b/benchmarks/tsb/bench_dataframe_apply.ts
index 32a99a68..3e0a0020 100644
--- a/benchmarks/tsb/bench_dataframe_apply.ts
+++ b/benchmarks/tsb/bench_dataframe_apply.ts
@@ -13,12 +13,12 @@ const b = Float64Array.from({ length: ROWS }, (_, i) => i * 2.0);
 const df = new DataFrame({ a, b });
 
 for (let i = 0; i < WARMUP; i++) {
-  df.apply((row) => (row["a"] as number) + (row["b"] as number), { axis: 1 });
+  df.apply((row) => (row.a as number) + (row.b as number), { axis: 1 });
 }
 
 const start = performance.now();
 for (let i = 0; i < ITERATIONS; i++) {
-  df.apply((row) => (row["a"] as number) + (row["b"] as number), { axis: 1 });
+  df.apply((row) => (row.a as number) + (row.b as number), { axis: 1 });
 }
 const total = performance.now() - start;
 
diff --git a/benchmarks/tsb/bench_dataframe_astype.ts b/benchmarks/tsb/bench_dataframe_astype.ts
new file mode 100644
index 00000000..39a34529
--- /dev/null
+++ b/benchmarks/tsb/bench_dataframe_astype.ts
@@ -0,0 +1,36 @@
+/**
+ * Benchmark: DataFrame.astype() — cast column dtypes.
+ * Outputs JSON: {"function": "dataframe_astype", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+  b: Array.from({ length: SIZE }, (_, i) => i),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.astype({ a: "float32", b: "int32" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.astype({ a: "float32", b: "int32" });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_astype",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_dataframe_dropna.ts b/benchmarks/tsb/bench_dataframe_dropna.ts
index e4fef46b..87fd867a 100644
--- a/benchmarks/tsb/bench_dataframe_dropna.ts
+++ b/benchmarks/tsb/bench_dataframe_dropna.ts
@@ -7,8 +7,8 @@ const ROWS = 100_000;
 const WARMUP = 5;
 const ITERATIONS = 20;
 
-const a = Float64Array.from({ length: ROWS }, (_, i) => (i % 10 === 0 ? NaN : i * 1.1));
-const b = Float64Array.from({ length: ROWS }, (_, i) => (i % 7 === 0 ? NaN : i * 2.2));
+const a = Float64Array.from({ length: ROWS }, (_, i) => (i % 10 === 0 ? Number.NaN : i * 1.1));
+const b = Float64Array.from({ length: ROWS }, (_, i) => (i % 7 === 0 ? Number.NaN : i * 2.2));
 const df = new DataFrame({ a, b });
 
 for (let i = 0; i < WARMUP; i++) {
diff --git a/benchmarks/tsb/bench_dataframe_filter.ts b/benchmarks/tsb/bench_dataframe_filter.ts
index 57d78bd7..efbcc1cd 100644
--- a/benchmarks/tsb/bench_dataframe_filter.ts
+++ b/benchmarks/tsb/bench_dataframe_filter.ts
@@ -11,12 +11,12 @@ const vals = Float64Array.from({ length: ROWS }, (_, i) => i * 0.1);
 const df = new DataFrame({ value: vals });
 
 for (let i = 0; i < WARMUP; i++) {
-  df.filter((row) => (row["value"] as number) > 5000);
+  df.filter((row) => (row.value as number) > 5000);
 }
 
 const start = performance.now();
 for (let i = 0; i < ITERATIONS; i++) {
-  df.filter((row) => (row["value"] as number) > 5000);
+  df.filter((row) => (row.value as number) > 5000);
 }
 const total = performance.now() - start;
 
diff --git a/benchmarks/tsb/bench_dataframe_head_tail.ts b/benchmarks/tsb/bench_dataframe_head_tail.ts
new file mode 100644
index 00000000..b903c6ab
--- /dev/null
+++ b/benchmarks/tsb/bench_dataframe_head_tail.ts
@@ -0,0 +1,39 @@
+/**
+ * Benchmark: DataFrame.head() and .tail() — slice first/last N rows.
+ * Outputs JSON: {"function": "dataframe_head_tail", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i * 1.0),
+  b: Array.from({ length: SIZE }, (_, i) => i * 2),
+  c: Array.from({ length: SIZE }, (_, i) => String(i)),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.head(100);
+  df.tail(100);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.head(100);
+  df.tail(100);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "dataframe_head_tail",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_diff.ts b/benchmarks/tsb/bench_diff.ts
new file mode 100644
index 00000000..b65b42ac
--- /dev/null
+++ b/benchmarks/tsb/bench_diff.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.diff() — first discrete difference.
+ * Outputs JSON: {"function": "diff", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.1 + 0.5) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.diff();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.diff();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "diff",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_drop_duplicates.ts b/benchmarks/tsb/bench_drop_duplicates.ts
new file mode 100644
index 00000000..bfc65bc6
--- /dev/null
+++ b/benchmarks/tsb/bench_drop_duplicates.ts
@@ -0,0 +1,36 @@
+/**
+ * Benchmark: DataFrame.drop_duplicates() — remove duplicate rows.
+ * Outputs JSON: {"function": "drop_duplicates", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i % 1000),
+  b: Array.from({ length: SIZE }, (_, i) => i % 500),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.drop_duplicates();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.drop_duplicates();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "drop_duplicates",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_duplicated.ts b/benchmarks/tsb/bench_duplicated.ts
new file mode 100644
index 00000000..054e80e9
--- /dev/null
+++ b/benchmarks/tsb/bench_duplicated.ts
@@ -0,0 +1,36 @@
+/**
+ * Benchmark: DataFrame.duplicated() — detect duplicate rows.
+ * Outputs JSON: {"function": "duplicated", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const df = new DataFrame({
+  a: Array.from({ length: SIZE }, (_, i) => i % 1000),
+  b: Array.from({ length: SIZE }, (_, i) => i % 500),
+});
+
+for (let i = 0; i < WARMUP; i++) {
+  df.duplicated();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.duplicated();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "duplicated",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_expanding_mean.ts b/benchmarks/tsb/bench_expanding_mean.ts
new file mode 100644
index 00000000..8f06c721
--- /dev/null
+++ b/benchmarks/tsb/bench_expanding_mean.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.expanding().mean() — expanding window mean.
+ * Outputs JSON: {"function": "expanding_mean", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.1 + 0.5) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.expanding().mean();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.expanding().mean();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "expanding_mean",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_interpolate.ts b/benchmarks/tsb/bench_interpolate.ts
new file mode 100644
index 00000000..cc1dc495
--- /dev/null
+++ b/benchmarks/tsb/bench_interpolate.ts
@@ -0,0 +1,34 @@
+/**
+ * Benchmark: Series.interpolate() — linear interpolation over NaN values.
+ * Outputs JSON: {"function": "interpolate", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data = Array.from({ length: SIZE }, (_, i) => (i % 5 === 0 ? Number.NaN : i * 1.0));
+const s = new Series({ data });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.interpolate({ method: "linear" });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.interpolate({ method: "linear" });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "interpolate",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_isin.ts b/benchmarks/tsb/bench_isin.ts
new file mode 100644
index 00000000..2f3741b1
--- /dev/null
+++ b/benchmarks/tsb/bench_isin.ts
@@ -0,0 +1,34 @@
+/**
+ * Benchmark: Series.isin() — membership test.
+ * Outputs JSON: {"function": "isin", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 5000) });
+const testSet = Array.from({ length: 2500 }, (_, i) => i);
+
+for (let i = 0; i < WARMUP; i++) {
+  s.isin(testSet);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.isin(testSet);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "isin",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_melt.ts b/benchmarks/tsb/bench_melt.ts
new file mode 100644
index 00000000..fc8a3e1f
--- /dev/null
+++ b/benchmarks/tsb/bench_melt.ts
@@ -0,0 +1,37 @@
+/**
+ * Benchmark: DataFrame.melt — unpivots wide-format DataFrame to long-format.
+ * Outputs JSON: {"function": "melt", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const SIZE = 10_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const cols: Record<string, number[]> = {};
+for (let i = 1; i <= 5; i++) {
+  cols[`col${i}`] = Array.from({ length: SIZE }, (_, j) => j * i + 0.5);
+}
+const df = new DataFrame(cols);
+
+for (let i = 0; i < WARMUP; i++) {
+  df.melt({ idVars: ["col1"], valueVars: ["col2", "col3", "col4", "col5"] });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.melt({ idVars: ["col1"], valueVars: ["col2", "col3", "col4", "col5"] });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "melt",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_nlargest.ts b/benchmarks/tsb/bench_nlargest.ts
new file mode 100644
index 00000000..609dce74
--- /dev/null
+++ b/benchmarks/tsb/bench_nlargest.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.nlargest() — get the n largest values.
+ * Outputs JSON: {"function": "nlargest", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.1 + 0.5) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.nlargest(100);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.nlargest(100);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "nlargest",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_pct_change.ts b/benchmarks/tsb/bench_pct_change.ts
new file mode 100644
index 00000000..5c142bc7
--- /dev/null
+++ b/benchmarks/tsb/bench_pct_change.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.pct_change() — percentage change between elements.
+ * Outputs JSON: {"function": "pct_change", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.1 + 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.pct_change();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.pct_change();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "pct_change",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_qcut.ts b/benchmarks/tsb/bench_qcut.ts
new file mode 100644
index 00000000..5746722b
--- /dev/null
+++ b/benchmarks/tsb/bench_qcut.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: qcut() — quantile-based binning.
+ * Outputs JSON: {"function": "qcut", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series, qcut } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  qcut(s, { q: 10 });
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  qcut(s, { q: 10 });
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "qcut",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_rank.ts b/benchmarks/tsb/bench_rank.ts
new file mode 100644
index 00000000..93c245b9
--- /dev/null
+++ b/benchmarks/tsb/bench_rank.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.rank() — rank values with average tie-breaking.
+ * Outputs JSON: {"function": "rank", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => (i % 1000) * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.rank();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.rank();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "rank",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_rolling_std.ts b/benchmarks/tsb/bench_rolling_std.ts
new file mode 100644
index 00000000..67bc1335
--- /dev/null
+++ b/benchmarks/tsb/bench_rolling_std.ts
@@ -0,0 +1,34 @@
+/**
+ * Benchmark: Series.rolling().std() — rolling standard deviation.
+ * Outputs JSON: {"function": "rolling_std", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WINDOW = 20;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.1 + 0.5) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.rolling(WINDOW).std();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.rolling(WINDOW).std();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "rolling_std",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_series_abs.ts b/benchmarks/tsb/bench_series_abs.ts
new file mode 100644
index 00000000..1034fdba
--- /dev/null
+++ b/benchmarks/tsb/bench_series_abs.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.abs() — element-wise absolute value.
+ * Outputs JSON: {"function": "series_abs", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => (i - 50000) * 1.0) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.abs();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.abs();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "series_abs",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_series_fillna.ts b/benchmarks/tsb/bench_series_fillna.ts
index 3e658b01..86c259fb 100644
--- a/benchmarks/tsb/bench_series_fillna.ts
+++ b/benchmarks/tsb/bench_series_fillna.ts
@@ -8,7 +8,7 @@ const WARMUP = 5;
 const ITERATIONS = 20;
 
 // Create series with every 5th value as NaN
-const data = Float64Array.from({ length: ROWS }, (_, i) => (i % 5 === 0 ? NaN : i * 1.1));
+const data = Float64Array.from({ length: ROWS }, (_, i) => (i % 5 === 0 ? Number.NaN : i * 1.1));
 const s = new Series(data);
 
 for (let i = 0; i < WARMUP; i++) {
diff --git a/benchmarks/tsb/bench_series_map.ts b/benchmarks/tsb/bench_series_map.ts
new file mode 100644
index 00000000..899cd0bb
--- /dev/null
+++ b/benchmarks/tsb/bench_series_map.ts
@@ -0,0 +1,34 @@
+/**
+ * Benchmark: Series.map() with a dictionary lookup.
+ * Outputs JSON: {"function": "series_map", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 1000) });
+const lookup = new Map<number, number>(Array.from({ length: 1000 }, (_, i) => [i, i * 2.5]));
+
+for (let i = 0; i < WARMUP; i++) {
+  s.map(lookup);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.map(lookup);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "series_map",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_series_nunique.ts b/benchmarks/tsb/bench_series_nunique.ts
new file mode 100644
index 00000000..3a40da23
--- /dev/null
+++ b/benchmarks/tsb/bench_series_nunique.ts
@@ -0,0 +1,33 @@
+/**
+ * Benchmark: Series.nunique() — count unique values.
+ * Outputs JSON: {"function": "series_nunique", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i % 1000) });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.nunique();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.nunique();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "series_nunique",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_stack.ts b/benchmarks/tsb/bench_stack.ts
new file mode 100644
index 00000000..6a4bb944
--- /dev/null
+++ b/benchmarks/tsb/bench_stack.ts
@@ -0,0 +1,38 @@
+/**
+ * Benchmark: DataFrame.stack() — pivot innermost column level to row index.
+ * Outputs JSON: {"function": "stack", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { DataFrame } from "../../src/index.ts";
+
+const ROWS = 1_000;
+const COLS = 20;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const cols: Record<string, number[]> = {};
+for (let j = 1; j <= COLS; j++) {
+  cols[`c${j}`] = Array.from({ length: ROWS }, (_, i) => i * j + 0.5);
+}
+const df = new DataFrame(cols);
+
+for (let i = 0; i < WARMUP; i++) {
+  df.stack();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  df.stack();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "stack",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_unstack.ts b/benchmarks/tsb/bench_unstack.ts
new file mode 100644
index 00000000..9bebfac0
--- /dev/null
+++ b/benchmarks/tsb/bench_unstack.ts
@@ -0,0 +1,39 @@
+/**
+ * Benchmark: Series.unstack() — pivot innermost MultiIndex level to columns.
+ * Outputs JSON: {"function": "unstack", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const ROWS = 500;
+const COLS = 10;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const data = Array.from({ length: ROWS * COLS }, (_, i) => i * 1.0);
+const index = Array.from(
+  { length: ROWS * COLS },
+  (_, i) => [Math.floor(i / COLS), i % COLS] as [number, number],
+);
+const s = new Series({ data, index });
+
+for (let i = 0; i < WARMUP; i++) {
+  s.unstack();
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.unstack();
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "unstack",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/benchmarks/tsb/bench_where.ts b/benchmarks/tsb/bench_where.ts
new file mode 100644
index 00000000..14843151
--- /dev/null
+++ b/benchmarks/tsb/bench_where.ts
@@ -0,0 +1,34 @@
+/**
+ * Benchmark: Series.where() — conditional replacement.
+ * Outputs JSON: {"function": "where", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+ */
+import { Series } from "../../src/index.ts";
+
+const SIZE = 100_000;
+const WARMUP = 5;
+const ITERATIONS = 50;
+
+const s = new Series({ data: Array.from({ length: SIZE }, (_, i) => i * 1.0) });
+const cond = s.gt(50000.0);
+
+for (let i = 0; i < WARMUP; i++) {
+  s.where(cond, 0.0);
+}
+
+const times: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  const start = performance.now();
+  s.where(cond, 0.0);
+  times.push(performance.now() - start);
+}
+
+const totalMs = times.reduce((a, b) => a + b, 0);
+const meanMs = totalMs / ITERATIONS;
+console.log(
+  JSON.stringify({
+    function: "where",
+    mean_ms: Math.round(meanMs * 1000) / 1000,
+    iterations: ITERATIONS,
+    total_ms: Math.round(totalMs * 1000) / 1000,
+  }),
+);
diff --git a/biome.json b/biome.json
index 5e64d5ce..29a04fd7 100644
--- a/biome.json
+++ b/biome.json
@@ -69,6 +69,20 @@
         "rules": {
           "nursery": {
             "noSecrets": "off"
+          },
+          "complexity": {
+            "useLiteralKeys": "off"
+          }
+        }
+      }
+    },
+    {
+      "include": ["benchmarks/**"],
+      "linter": {
+        "rules": {
+          "suspicious": {
+            "noConsole": "off",
+            "noConsoleLog": "off"
           }
         }
       }
diff --git a/src/core/api_types.ts b/src/core/api_types.ts
index 860d2050..5b78bbd7 100644
--- a/src/core/api_types.ts
+++ b/src/core/api_types.ts
@@ -23,8 +23,8 @@
  * @module
  */
 
-import { Dtype } from "./dtype.ts";
 import type { DtypeName } from "../types.ts";
+import { Dtype } from "./dtype.ts";
 
 // ─── internal helper ──────────────────────────────────────────────────────────
 
@@ -95,14 +95,19 @@ export function isListLike(val: unknown): boolean {
     return false;
   }
   // Has Symbol.iterator and is not a plain number/boolean/bigint/symbol
-  if (typeof val === "number" || typeof val === "boolean" || typeof val === "bigint" || typeof val === "symbol") {
+  if (
+    typeof val === "number" ||
+    typeof val === "boolean" ||
+    typeof val === "bigint" ||
+    typeof val === "symbol"
+  ) {
     return false;
   }
   if (typeof val === "object" || typeof val === "function") {
     if (Symbol.iterator in (val as object)) {
       return true;
     }
-    const len = (val as Record<string, unknown>)["length"];
+    const len = (val as { readonly length?: unknown }).length;
     if (typeof len === "number" && len >= 0 && Number.isInteger(len)) {
       return true;
     }
@@ -134,7 +139,7 @@ export function isArrayLike(val: unknown): boolean {
   if (typeof val !== "object" && typeof val !== "function") {
     return false;
   }
-  const len = (val as Record<string, unknown>)["length"];
+  const len = (val as { readonly length?: unknown }).length;
   return typeof len === "number" && len >= 0 && Number.isInteger(len);
 }
 
@@ -192,7 +197,7 @@ export function isIterator(val: unknown): boolean {
   if (typeof val !== "object" && typeof val !== "function") {
     return false;
   }
-  return typeof (val as Record<string, unknown>)["next"] === "function";
+  return typeof (val as { readonly next?: unknown }).next === "function";
 }
 
 /**
diff --git a/src/core/attrs.ts b/src/core/attrs.ts
index 81c6be1c..771f5325 100644
--- a/src/core/attrs.ts
+++ b/src/core/attrs.ts
@@ -227,7 +227,9 @@ export function setAttr(obj: object, key: string, value: unknown): void {
  */
 export function deleteAttr(obj: object, key: string): void {
   const existing = registry.get(obj);
-  if (existing === undefined) return;
+  if (existing === undefined) {
+    return;
+  }
   const { [key]: _removed, ...rest } = existing;
   if (Object.keys(rest).length === 0) {
     registry.delete(obj);
diff --git a/src/core/frame.ts b/src/core/frame.ts
index 1e260fe0..578cc4b8 100644
--- a/src/core/frame.ts
+++ b/src/core/frame.ts
@@ -100,12 +100,19 @@ export class DataFrame {
    * Low-level constructor.  Prefer the static factory methods for typical use.
    *
    * @param columns - Ordered map of column name → Series (all same length and index).
-   * @param index   - Row index (must match each Series' length).
+   * @param index   - Row index (must match each Series' length). Defaults to a
+   *                  `RangeIndex` derived from the first Series when omitted.
    */
-  constructor(columns: ReadonlyMap<string, Series<Scalar>>, index: Index<Label>) {
+  constructor(
+    columns: ReadonlyMap<string, Series<Scalar>>,
+    index?: Index<Label>,
+    columnNames?: readonly string[],
+  ) {
+    const firstSeries = columns.values().next().value as Series<Scalar> | undefined;
+    const nRows = firstSeries !== undefined ? firstSeries.values.length : 0;
     this._columns = columns;
-    this.index = index;
-    this.columns = new Index<string>([...columns.keys()]);
+    this.index = index ?? defaultRowIndex(nRows);
+    this.columns = new Index<string>(columnNames ?? [...columns.keys()]);
   }
 
   /**
diff --git a/src/core/index.ts b/src/core/index.ts
index 08713cae..255aade6 100644
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -15,7 +15,13 @@ export { CategoricalAccessor } from "./cat_accessor.ts";
 export type { CatSeriesLike } from "./cat_accessor.ts";
 export { MultiIndex } from "./multi_index.ts";
 export type { MultiIndexOptions } from "./multi_index.ts";
-export { insertColumn, popColumn, reorderColumns, moveColumn, dataFrameFromPairs } from "./insert_pop.ts";
+export {
+  insertColumn,
+  popColumn,
+  reorderColumns,
+  moveColumn,
+  dataFrameFromPairs,
+} from "./insert_pop.ts";
 export type { PopResult } from "./insert_pop.ts";
 export { toDictOriented, fromDictOriented } from "./to_from_dict.ts";
 export type {
diff --git a/src/core/insert_pop.ts b/src/core/insert_pop.ts
index d56c42bc..164e882e 100644
--- a/src/core/insert_pop.ts
+++ b/src/core/insert_pop.ts
@@ -27,7 +27,7 @@
  */
 
 import type { Label, Scalar } from "../types.ts";
-import { Index } from "./base-index.ts";
+import type { Index } from "./base-index.ts";
 import { DataFrame } from "./frame.ts";
 import { Series } from "./series.ts";
 
@@ -82,23 +82,28 @@ export function insertColumn(
   }
 
   // Rebuild the column map, inserting the new column at position `loc`.
+  const colNames: string[] = [];
   const colMap = new Map<string, Series<Scalar>>();
   let idx = 0;
 
   for (const colName of df.columns.values) {
     if (idx === loc) {
-      colMap.set(column, series);
+      colNames.push(column);
     }
+    colNames.push(colName);
     colMap.set(colName, df.col(colName));
     idx++;
   }
 
   // Handle insertion at the end (loc === nCols).
   if (loc === nCols) {
-    colMap.set(column, series);
+    colNames.push(column);
   }
 
-  return new DataFrame(colMap, df.index);
+  // Always add the new column data to the map (last-wins for duplicate names).
+  colMap.set(column, series);
+
+  return new DataFrame(colMap, df.index, colNames);
 }
 
 // ─── popColumn ────────────────────────────────────────────────────────────────
diff --git a/src/core/pipe_apply.ts b/src/core/pipe_apply.ts
index 2f0b0180..dfa2259b 100644
--- a/src/core/pipe_apply.ts
+++ b/src/core/pipe_apply.ts
@@ -45,12 +45,7 @@ import type { Label, Scalar } from "../types.ts";
 export function pipe<A>(value: A): A;
 export function pipe<A, B>(value: A, fn1: (a: A) => B): B;
 export function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;
-export function pipe<A, B, C, D>(
-  value: A,
-  fn1: (a: A) => B,
-  fn2: (b: B) => C,
-  fn3: (c: C) => D,
-): D;
+export function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;
 export function pipe<A, B, C, D, E>(
   value: A,
   fn1: (a: A) => B,
@@ -119,7 +114,11 @@ export function seriesApply(
   for (let i = 0; i < n; i++) {
     out[i] = fn(series.iat(i), series.index.at(i), i);
   }
-  return new Series({ data: out, index: series.index, ...(series.name !== null ? { name: series.name } : {}) });
+  return new Series({
+    data: out,
+    index: series.index,
+    ...(series.name !== null ? { name: series.name } : {}),
+  });
 }
 
 /**
@@ -141,7 +140,11 @@ export function seriesTransform(
   for (let i = 0; i < n; i++) {
     out[i] = fn(series.iat(i));
   }
-  return new Series({ data: out, index: series.index, ...(series.name !== null ? { name: series.name } : {}) });
+  return new Series({
+    data: out,
+    index: series.index,
+    ...(series.name !== null ? { name: series.name } : {}),
+  });
 }
 
 // ─── DataFrame apply ──────────────────────────────────────────────────────────
@@ -272,7 +275,11 @@ export function dataFrameTransform(
  */
 export function dataFrameTransformRows(
   df: DataFrame,
-  fn: (row: Readonly<Record<string, Scalar>>, rowLabel: Label, position: number) => Readonly<Record<string, Scalar>>,
+  fn: (
+    row: Readonly<Record<string, Scalar>>,
+    rowLabel: Label,
+    position: number,
+  ) => Readonly<Record<string, Scalar>>,
 ): DataFrame {
   const colNames = df.columns.values as readonly string[];
   const rowLabels = df.index.values as readonly Label[];
@@ -290,7 +297,9 @@ export function dataFrameTransformRows(
     const rowOut = fn(rowIn, rowLabels[i] as Label, i);
     for (const c of colNames) {
       const colArr = colArrays.get(c);
-      if (colArr === undefined) continue;
+      if (colArr === undefined) {
+        continue;
+      }
       // use the transformed value if present, else keep original
       colArr[i] = c in rowOut ? (rowOut[c] as Scalar) : rowIn[c];
     }
diff --git a/src/core/to_from_dict.ts b/src/core/to_from_dict.ts
index 975a7fc5..eb4b1224 100644
--- a/src/core/to_from_dict.ts
+++ b/src/core/to_from_dict.ts
@@ -25,12 +25,20 @@
 import type { Label, Scalar } from "../types.ts";
 import { Index } from "./base-index.ts";
 import { DataFrame } from "./frame.ts";
-import { Series } from "./series.ts";
+import type { Series } from "./series.ts";
 
 // ─── public types ──────────────────────────────────────────────────────────────
 
 /** Orient values supported by {@link toDictOriented}. */
-export type ToDictOrient = "dict" | "columns" | "list" | "series" | "split" | "tight" | "records" | "index";
+export type ToDictOrient =
+  | "dict"
+  | "columns"
+  | "list"
+  | "series"
+  | "split"
+  | "tight"
+  | "records"
+  | "index";
 
 /** Orient values supported by {@link fromDictOriented}. */
 export type FromDictOrient = "columns" | "index" | "split" | "tight";
@@ -68,6 +76,15 @@ function isDefaultRange(labels: readonly Label[]): boolean {
   return true;
 }
 
+/** Return type union for all {@link toDictOriented} orient values. */
+type ToDictResult =
+  | Record<string, Record<string, Scalar>>
+  | Record<string, Scalar[]>
+  | Record<string, Series<Scalar>>
+  | DictSplit
+  | DictTight
+  | Record<string, Scalar>[];
+
 // ─── toDictOriented ───────────────────────────────────────────────────────────
 
 /**
@@ -78,17 +95,20 @@ function isDefaultRange(labels: readonly Label[]): boolean {
  * @param df     Source DataFrame.
  * @param orient Output structure. Defaults to `"dict"`.
  */
-export function toDictOriented(df: DataFrame, orient: "dict" | "columns"): Record<string, Record<string, Scalar>>;
+export function toDictOriented(
+  df: DataFrame,
+  orient: "dict" | "columns",
+): Record<string, Record<string, Scalar>>;
 export function toDictOriented(df: DataFrame, orient: "list"): Record<string, Scalar[]>;
 export function toDictOriented(df: DataFrame, orient: "series"): Record<string, Series<Scalar>>;
 export function toDictOriented(df: DataFrame, orient: "split"): DictSplit;
 export function toDictOriented(df: DataFrame, orient: "tight"): DictTight;
 export function toDictOriented(df: DataFrame, orient: "records"): Record<string, Scalar>[];
-export function toDictOriented(df: DataFrame, orient: "index"): Record<string, Record<string, Scalar>>;
 export function toDictOriented(
   df: DataFrame,
-  orient: ToDictOrient = "dict",
-): Record<string, unknown> | unknown[] {
+  orient: "index",
+): Record<string, Record<string, Scalar>>;
+export function toDictOriented(df: DataFrame, orient: ToDictOrient = "dict"): ToDictResult {
   const colNames = [...df.columns.values];
   const rowLabels = [...(df.index.values as Label[])];
   const nRows = df.index.size;
@@ -201,10 +221,7 @@ export function fromDictOriented(
   orient: "index",
 ): DataFrame;
 export function fromDictOriented(data: SplitInput, orient: "split" | "tight"): DataFrame;
-export function fromDictOriented(
-  data: unknown,
-  orient: FromDictOrient = "columns",
-): DataFrame {
+export function fromDictOriented(data: unknown, orient: FromDictOrient = "columns"): DataFrame {
   switch (orient) {
     case "columns": {
       const colsData = data as Record<string, readonly Scalar[]>;
@@ -266,8 +283,11 @@ function buildFromSplit(input: SplitInput): DataFrame {
   for (const row of data) {
     for (let j = 0; j < columns.length; j++) {
       const col = columns[j];
+      if (col === undefined) {
+        continue;
+      }
       const arr = colArrays[col];
-      if (col !== undefined && arr !== undefined) {
+      if (arr !== undefined) {
         arr.push(row[j] ?? null);
       }
     }
diff --git a/src/index.ts b/src/index.ts
index ab2dbcdc..44aa1357 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -115,10 +115,22 @@ export type { ClipOptions, RoundOptions, DataFrameElemOptions } from "./stats/in
 export { valueCounts, dataFrameValueCounts } from "./stats/index.ts";
 export type { ValueCountsOptions, DataFrameValueCountsOptions } from "./stats/index.ts";
 
-export { insertColumn, popColumn, reorderColumns, moveColumn, dataFrameFromPairs } from "./core/index.ts";
+export {
+  insertColumn,
+  popColumn,
+  reorderColumns,
+  moveColumn,
+  dataFrameFromPairs,
+} from "./core/index.ts";
 export type { PopResult } from "./core/index.ts";
 export { toDictOriented, fromDictOriented } from "./core/index.ts";
-export type { ToDictOrient, FromDictOrient, DictSplit, DictTight, SplitInput } from "./core/index.ts";
+export type {
+  ToDictOrient,
+  FromDictOrient,
+  DictSplit,
+  DictTight,
+  SplitInput,
+} from "./core/index.ts";
 export { wideToLong } from "./reshape/index.ts";
 export type { WideToLongOptions } from "./reshape/index.ts";
 export { cut, qcut } from "./stats/index.ts";
@@ -132,7 +144,16 @@ export type {
   SeriesWhereOptions,
   DataFrameWhereOptions,
 } from "./stats/index.ts";
-export { isna, notna, isnull, notnull, fillna, dropna, countna, countValid } from "./stats/index.ts";
+export {
+  isna,
+  notna,
+  isnull,
+  notnull,
+  fillna,
+  dropna,
+  countna,
+  countValid,
+} from "./stats/index.ts";
 export type { IsnaInput, FillnaOptions, DropnaOptions } from "./stats/index.ts";
 export {
   getAttrs,
diff --git a/src/reshape/wide_to_long.ts b/src/reshape/wide_to_long.ts
index 7ac62ba8..e7b4cce3 100644
--- a/src/reshape/wide_to_long.ts
+++ b/src/reshape/wide_to_long.ts
@@ -38,10 +38,10 @@
  * @module
  */
 
-import type { Label, Scalar } from "../types.ts";
-import { Index } from "../core/base-index.ts";
+import type { Index } from "../core/base-index.ts";
 import { DataFrame } from "../core/frame.ts";
 import { RangeIndex } from "../core/range-index.ts";
+import type { Label, Scalar } from "../types.ts";
 
 // ─── public types ──────────────────────────────────────────────────────────────
 
@@ -100,7 +100,7 @@ function collectSuffixes(
     // Sort numerically when both look like integers, otherwise lexicographically.
     const na = Number(a);
     const nb = Number(b);
-    if (!Number.isNaN(na) && !Number.isNaN(nb)) {
+    if (!(Number.isNaN(na) || Number.isNaN(nb))) {
       return na - nb;
     }
     return a < b ? -1 : a > b ? 1 : 0;
@@ -193,7 +193,8 @@ export function wideToLong(
         const arr = stubArrays[stub];
         if (arr !== undefined) {
           const wideCol = df.get(wideColName);
-          const val: Scalar = wideCol !== undefined ? ((wideCol.values[row] ?? null) as Scalar) : null;
+          const val: Scalar =
+            wideCol !== undefined ? ((wideCol.values[row] ?? null) as Scalar) : null;
           arr.push(val);
         }
       }
diff --git a/src/stats/categorical_ops.ts b/src/stats/categorical_ops.ts
index f9abbb0d..0ec33cc4 100644
--- a/src/stats/categorical_ops.ts
+++ b/src/stats/categorical_ops.ts
@@ -108,11 +108,11 @@ export function catFromCodes(
   const { ordered = false, name = null } = opts;
   const cats = uniqueKeys(categories);
   const values: Scalar[] = codes.map((code) => {
-    if (code === -1) return null;
+    if (code === -1) {
+      return null;
+    }
     if (code < -1 || code >= cats.length) {
-      throw new RangeError(
-        `catFromCodes: code ${code} is out of range [0, ${cats.length - 1}]`,
-      );
+      throw new RangeError(`catFromCodes: code ${code} is out of range [0, ${cats.length - 1}]`);
     }
     return cats[code] as Scalar;
   });
@@ -169,9 +169,7 @@ export function catUnionCategories(a: CatSeriesLike, b: CatSeriesLike): CatSerie
  */
 export function catIntersectCategories(a: CatSeriesLike, b: CatSeriesLike): CatSeriesLike {
   const bSet = new Set((b.cat.categories.values as Scalar[]).map(String));
-  const intersected = (a.cat.categories.values as Scalar[]).filter((c) =>
-    bSet.has(String(c)),
-  );
+  const intersected = (a.cat.categories.values as Scalar[]).filter((c) => bSet.has(String(c)));
   return a.cat.setCategories(intersected, a.cat.ordered);
 }
 
@@ -194,9 +192,7 @@ export function catIntersectCategories(a: CatSeriesLike, b: CatSeriesLike): CatS
  */
 export function catDiffCategories(a: CatSeriesLike, b: CatSeriesLike): CatSeriesLike {
   const bSet = new Set((b.cat.categories.values as Scalar[]).map(String));
-  const remaining = (a.cat.categories.values as Scalar[]).filter(
-    (c) => !bSet.has(String(c)),
-  );
+  const remaining = (a.cat.categories.values as Scalar[]).filter((c) => !bSet.has(String(c)));
   return a.cat.setCategories(remaining, a.cat.ordered);
 }
 
@@ -216,9 +212,13 @@ export function catDiffCategories(a: CatSeriesLike, b: CatSeriesLike): CatSeries
 export function catEqualCategories(a: CatSeriesLike, b: CatSeriesLike): boolean {
   const aSet = new Set((a.cat.categories.values as Scalar[]).map(String));
   const bSet = new Set((b.cat.categories.values as Scalar[]).map(String));
-  if (aSet.size !== bSet.size) return false;
+  if (aSet.size !== bSet.size) {
+    return false;
+  }
   for (const c of aSet) {
-    if (!bSet.has(c)) return false;
+    if (!bSet.has(c)) {
+      return false;
+    }
   }
   return true;
 }
@@ -249,12 +249,16 @@ export function catSortByFreq(
   const { ascending = false } = opts;
   const cats = series.cat.categories.values as Scalar[];
   const freq = new Map<string, number>();
-  for (const c of cats) freq.set(String(c), 0);
+  for (const c of cats) {
+    freq.set(String(c), 0);
+  }
   for (const v of series.values) {
     if (!isMissing(v)) {
       const k = String(v);
       const prev = freq.get(k);
-      if (prev !== undefined) freq.set(k, prev + 1);
+      if (prev !== undefined) {
+        freq.set(k, prev + 1);
+      }
     }
   }
   const sorted = [...cats].sort((a, b) => {
@@ -312,7 +316,9 @@ export function catToOrdinal(series: CatSeriesLike, order: readonly Scalar[]): C
 export function catFreqTable(series: CatSeriesLike): Record<string, number> {
   const cats = series.cat.categories.values as Scalar[];
   const freq: Record<string, number> = {};
-  for (const c of cats) freq[String(c)] = 0;
+  for (const c of cats) {
+    freq[String(c)] = 0;
+  }
   for (const v of series.values) {
     if (!isMissing(v)) {
       const k = String(v);
@@ -364,7 +370,9 @@ export function catCrossTab(
   const counts = new Map<string, Map<string, number>>();
   for (const r of rowCats) {
     const row = new Map<string, number>();
-    for (const c of colCats) row.set(String(c), 0);
+    for (const c of colCats) {
+      row.set(String(c), 0);
+    }
     counts.set(String(r), row);
   }
 
@@ -374,18 +382,26 @@ export function catCrossTab(
   for (let i = 0; i < n; i++) {
     const av = aVals[i];
     const bv = bVals[i];
-    if (isMissing(av) || isMissing(bv)) continue;
+    if (isMissing(av) || isMissing(bv)) {
+      continue;
+    }
     const row = counts.get(String(av));
-    if (row === undefined) continue;
+    if (row === undefined) {
+      continue;
+    }
     const prev = row.get(String(bv));
-    if (prev !== undefined) row.set(String(bv), prev + 1);
+    if (prev !== undefined) {
+      row.set(String(bv), prev + 1);
+    }
   }
 
   // Compute total for normalization
   let total = 0;
   if (normalize) {
     for (const row of counts.values()) {
-      for (const v of row.values()) total += v;
+      for (const v of row.values()) {
+        total += v;
+      }
     }
   }
 
@@ -405,7 +421,11 @@ export function catCrossTab(
     const rowTotals: Scalar[] = rowCats.map((r) => {
       let sum = 0;
       const row = counts.get(String(r));
-      if (row) for (const v of row.values()) sum += v;
+      if (row) {
+        for (const v of row.values()) {
+          sum += v;
+        }
+      }
       return normalize && total > 0 ? sum / total : sum;
     });
     data[marginsName] = rowTotals;
@@ -436,7 +456,9 @@ export function catCrossTab(
     // Ensure all column arrays have the same length
     for (const col of allCols) {
       const arr = data[col];
-      if (arr === undefined) data[col] = rowLabels.map(() => 0);
+      if (arr === undefined) {
+        data[col] = rowLabels.map(() => 0);
+      }
     }
   }
 
@@ -475,9 +497,7 @@ export function catRecode(
   const cats = series.cat.categories.values as Scalar[];
   const newCats = cats.map((c): Scalar => {
     const k = String(c);
-    return Object.prototype.hasOwnProperty.call(mapping, k)
-      ? (mapping[k] as string)
-      : c;
+    return Object.prototype.hasOwnProperty.call(mapping, k) ? (mapping[k] as string) : c;
   });
   return series.cat.renameCategories(newCats);
 }
diff --git a/src/stats/cut_qcut.ts b/src/stats/cut_qcut.ts
index d24b3dda..ceb188fa 100644
--- a/src/stats/cut_qcut.ts
+++ b/src/stats/cut_qcut.ts
@@ -98,7 +98,10 @@ export interface QCutOptions {
 
 /** Format a numeric edge to at most `precision` decimal places. */
 function fmt(v: number, precision: number): string {
-  return v.toFixed(precision).replace(/\.?0+$/, "").replace(/^-0$/, "0");
+  return v
+    .toFixed(precision)
+    .replace(/\.?0+$/, "")
+    .replace(/^-0$/, "0");
 }
 
 /** Build interval label string from two edges. */
@@ -110,13 +113,21 @@ function intervalLabel(lo: number, hi: number, right: boolean, precision: number
 
 /** Compute the k-th quantile (0–1) of a sorted (non-NaN) array using linear interpolation. */
 function quantileOfSorted(sorted: readonly number[], q: number): number {
-  if (sorted.length === 0) return Number.NaN;
-  if (q <= 0) return sorted[0] as number;
-  if (q >= 1) return sorted[sorted.length - 1] as number;
+  if (sorted.length === 0) {
+    return Number.NaN;
+  }
+  if (q <= 0) {
+    return sorted[0] as number;
+  }
+  if (q >= 1) {
+    return sorted.at(-1) as number;
+  }
   const idx = q * (sorted.length - 1);
   const lo = Math.floor(idx);
   const hi = Math.ceil(idx);
-  if (lo === hi) return sorted[lo] as number;
+  if (lo === hi) {
+    return sorted[lo] as number;
+  }
   const frac = idx - lo;
   return (sorted[lo] as number) * (1 - frac) + (sorted[hi] as number) * frac;
 }
@@ -125,7 +136,7 @@ function quantileOfSorted(sorted: readonly number[], q: number): number {
 function deduplicateEdges(edges: number[], duplicates: "raise" | "drop"): number[] {
   const deduped: number[] = [edges[0] as number];
   for (let i = 1; i < edges.length; i++) {
-    if ((edges[i] as number) === deduped[deduped.length - 1]) {
+    if ((edges[i] as number) === deduped.at(-1)) {
       if (duplicates === "raise") {
         throw new Error(
           `Duplicate bin edge ${edges[i]}. Pass duplicates="drop" to silently remove duplicates.`,
@@ -148,22 +159,30 @@ function assignBins(
 ): Array<number | null> {
   const n = edges.length - 1; // number of bins
   return values.map((v) => {
-    if (!Number.isFinite(v) || Number.isNaN(v)) return null;
+    if (!Number.isFinite(v) || Number.isNaN(v)) {
+      return null;
+    }
     // Binary search for the bin
     let lo = 0;
     let hi = n - 1;
     while (lo < hi) {
       const mid = (lo + hi) >> 1;
       const binHi = edges[mid + 1] as number;
-      const binLo = edges[mid] as number;
+      const _binLo = edges[mid] as number;
       if (right) {
         // (binLo, binHi]
-        if (v <= binHi) hi = mid;
-        else lo = mid + 1;
+        if (v <= binHi) {
+          hi = mid;
+        } else {
+          lo = mid + 1;
+        }
       } else {
         // [binLo, binHi)
-        if (v < binHi) hi = mid;
-        else lo = mid + 1;
+        if (v < binHi) {
+          hi = mid;
+        } else {
+          lo = mid + 1;
+        }
       }
     }
     // Validate the found bin
@@ -171,17 +190,23 @@ function assignBins(
     const binHi = edges[lo + 1] as number;
     if (right) {
       // (binLo, binHi] — but first bin may be [binLo, binHi] if include_lowest
-      if (v > binHi) return null;
+      if (v > binHi) {
+        return null;
+      }
       if (lo === 0 && include_lowest) {
-        if (v < binLo) return null;
-      } else {
-        if (v <= binLo) return null;
+        if (v < binLo) {
+          return null;
+        }
+      } else if (v <= binLo) {
+        return null;
       }
     } else {
       // [binLo, binHi)
       if (v < binLo || v >= binHi) {
         // Last bin includes the right edge
-        if (lo === n - 1 && v === binHi) return lo;
+        if (lo === n - 1 && v === binHi) {
+          return lo;
+        }
         return null;
       }
     }
@@ -239,6 +264,11 @@ export function cut(
     edges = Array.from({ length: bins + 1 }, (_, i) => mn + i * step);
     // Slightly extend the lower edge so the minimum value is included
     edges[0] = mn - step * 0.001;
+    // Guard against floating-point drift: ensure the last edge covers the max
+    const lastIdx = edges.length - 1;
+    if ((edges[lastIdx] as number) < mx) {
+      edges[lastIdx] = mx;
+    }
     edges = deduplicateEdges(edges, duplicates);
   } else {
     if (bins.length < 2) {
@@ -329,7 +359,7 @@ export function qcut(
         throw new Error("Quantile probabilities must be monotonically increasing.");
       }
     }
-    if ((quantiles[0] as number) < 0 || (quantiles[quantiles.length - 1] as number) > 1) {
+    if ((quantiles[0] as number) < 0 || (quantiles.at(-1) as number) > 1) {
       throw new Error("Quantile probabilities must be in [0, 1].");
     }
   }
@@ -349,7 +379,7 @@ export function qcut(
   const numBins = edges.length - 1;
   if (numBins < 1) {
     throw new Error(
-      "Not enough unique quantile edges. Try passing duplicates=\"drop\" or reducing `q`.",
+      'Not enough unique quantile edges. Try passing duplicates="drop" or reducing `q`.',
     );
   }
 
diff --git a/src/stats/format_ops.ts b/src/stats/format_ops.ts
index 148a85b1..387ef485 100644
--- a/src/stats/format_ops.ts
+++ b/src/stats/format_ops.ts
@@ -23,7 +23,7 @@
  * @module
  */
 
-import { DataFrame } from "../core/index.ts";
+import type { DataFrame } from "../core/index.ts";
 import { Series } from "../core/index.ts";
 import type { Scalar } from "../types.ts";
 
@@ -300,7 +300,10 @@ export interface SeriesToStringOptions {
  * @param series  The Series to render.
  * @param options Optional rendering options.
  */
-export function seriesToString(series: Series<Scalar>, options: SeriesToStringOptions = {}): string {
+export function seriesToString(
+  series: Series<Scalar>,
+  options: SeriesToStringOptions = {},
+): string {
   const maxRows = options.maxRows ?? 60;
   const fmt: Formatter = options.formatter ?? ((v: Scalar) => String(v ?? "NaN"));
   const displayName = options.name !== undefined ? options.name : series.name;
@@ -326,7 +329,7 @@ export function seriesToString(series: Series<Scalar>, options: SeriesToStringOp
   }
 
   if (truncated) {
-    lines.push(`...`);
+    lines.push("...");
   }
 
   const footer: string[] = [];
diff --git a/src/stats/notna_isna.ts b/src/stats/notna_isna.ts
index bd685c1c..f6ea17b0 100644
--- a/src/stats/notna_isna.ts
+++ b/src/stats/notna_isna.ts
@@ -284,8 +284,7 @@ function _dropnaRows(df: DataFrame, how: "any" | "all"): DataFrame {
   for (let i = 0; i < nRows; i++) {
     const rowMissing: boolean[] = colNames.map((col) => scalarIsna(df.col(col).iat(i)));
 
-    const shouldDrop =
-      how === "any" ? rowMissing.some(Boolean) : rowMissing.every(Boolean);
+    const shouldDrop = how === "any" ? rowMissing.some(Boolean) : rowMissing.every(Boolean);
 
     if (!shouldDrop) {
       keep.push(i);
@@ -321,8 +320,7 @@ function _dropnaColumns(df: DataFrame, how: "any" | "all"): DataFrame {
     const vals = series.values;
     const missingFlags = vals.map(scalarIsna);
 
-    const shouldDrop =
-      how === "any" ? missingFlags.some(Boolean) : missingFlags.every(Boolean);
+    const shouldDrop = how === "any" ? missingFlags.some(Boolean) : missingFlags.every(Boolean);
 
     if (!shouldDrop) {
       colMap.set(name, series);
diff --git a/src/stats/numeric_extended.ts b/src/stats/numeric_extended.ts
index c5534e71..fe6e4f1e 100644
--- a/src/stats/numeric_extended.ts
+++ b/src/stats/numeric_extended.ts
@@ -145,20 +145,22 @@ export function digitize(
     if (right) {
       // open left, closed right: bins[i-1] < v <= bins[i]
       for (let i = 0; i < n; i++) {
-        if (v <= (bins[i] as number)) {
-          return i - 1; // below first edge → -1
+        if (v < (bins[i] as number)) {
+          return i - 1; // below edge i → bin i-1
+        }
+        if (v === (bins[i] as number)) {
+          return i; // exactly at edge i → bin i (right-inclusive)
         }
       }
       return n - 1; // above last edge
-    } else {
-      // closed left, open right: bins[i-1] <= v < bins[i]
-      for (let i = 0; i < n; i++) {
-        if (v < (bins[i] as number)) {
-          return i - 1;
-        }
+    }
+    // closed left, open right: bins[i-1] <= v < bins[i]
+    for (let i = 0; i < n; i++) {
+      if (v < (bins[i] as number)) {
+        return i - 1;
       }
-      return n - 1; // at or above last edge
     }
+    return n - 1; // at or above last edge
   });
 }
 
@@ -300,7 +302,14 @@ export function linspace(start: number, stop: number, num = 50): number[] {
   const step = (stop - start) / (num - 1);
   const result: number[] = [];
   for (let i = 0; i < num; i++) {
-    result.push(i === num - 1 ? stop : start + i * step);
+    // Use exact values for first and last elements to avoid floating-point drift
+    if (i === 0) {
+      result.push(start);
+    } else if (i === num - 1) {
+      result.push(stop);
+    } else {
+      result.push(start + i * step);
+    }
   }
   return result;
 }
@@ -432,10 +441,7 @@ export function percentileOfScore(
  * // approximately [−1.5, −0.5, −0.5, −0.5, 0, 0, 1, 2] (normalised)
  * ```
  */
-export function zscore(
-  series: Series<Scalar>,
-  options?: ZscoreOptions,
-): Series<Scalar> {
+export function zscore(series: Series<Scalar>, options?: ZscoreOptions): Series<Scalar> {
   const ddof = options?.ddof ?? 1;
   const vals = series.values as readonly Scalar[];
   const nums = finiteNums(vals);
@@ -455,7 +461,7 @@ export function zscore(
     return series.withValues(nanVals) as Series<Scalar>;
   }
 
-  const zVals = vals.map((v) => (isNum(v) ? ((v - mean) / std) as Scalar : v));
+  const zVals = vals.map((v) => (isNum(v) ? (((v - mean) / std) as Scalar) : v));
   return series.withValues(zVals) as Series<Scalar>;
 }
 
@@ -481,10 +487,7 @@ export function zscore(
  * // → Series([0, 0.5, 1])
  * ```
  */
-export function minMaxNormalize(
-  series: Series<Scalar>,
-  options?: MinMaxOptions,
-): Series<Scalar> {
+export function minMaxNormalize(series: Series<Scalar>, options?: MinMaxOptions): Series<Scalar> {
   const rMin = options?.featureRangeMin ?? 0;
   const rMax = options?.featureRangeMax ?? 1;
   if (rMin >= rMax) {
@@ -508,7 +511,7 @@ export function minMaxNormalize(
   }
 
   const scaled = vals.map((v) =>
-    isNum(v) ? (((v - min) / span) * (rMax - rMin) + rMin) as Scalar : v,
+    isNum(v) ? ((((v - min) / span) * (rMax - rMin) + rMin) as Scalar) : v,
   );
   return series.withValues(scaled) as Series<Scalar>;
 }
@@ -532,10 +535,7 @@ export function minMaxNormalize(
  * // ≈ 0.5
  * ```
  */
-export function coefficientOfVariation(
-  series: Series<Scalar>,
-  options?: CvOptions,
-): number {
+export function coefficientOfVariation(series: Series<Scalar>, options?: CvOptions): number {
   const ddof = options?.ddof ?? 1;
   const vals = series.values as readonly Scalar[];
   const nums = finiteNums(vals);
diff --git a/src/stats/string_ops.ts b/src/stats/string_ops.ts
index 19d69e13..d55995b7 100644
--- a/src/stats/string_ops.ts
+++ b/src/stats/string_ops.ts
@@ -22,7 +22,7 @@
  */
 
 import { DataFrame, Series } from "../core/index.ts";
-import type { Label, Scalar } from "../types.ts";
+import type { Scalar } from "../types.ts";
 
 // ─── public types ─────────────────────────────────────────────────────────────
 
@@ -30,7 +30,7 @@ import type { Label, Scalar } from "../types.ts";
 export type NormalizeForm = "NFC" | "NFD" | "NFKC" | "NFKD";
 
 /** Input accepted by all string-op functions. */
-export type StrInput = Series<Scalar> | readonly string[] | string;
+export type StrInput = Series<Scalar> | readonly Scalar[] | string;
 
 /** Options for {@link strGetDummies}. */
 export interface GetDummiesOptions {
@@ -67,8 +67,12 @@ export interface ExtractAllOptions {
 
 /** Extract a plain string from a Scalar value; returns `""` for non-strings. */
 function scalarToStr(v: Scalar): string {
-  if (typeof v === "string") return v;
-  if (v === null || v === undefined) return "";
+  if (typeof v === "string") {
+    return v;
+  }
+  if (v === null || v === undefined) {
+    return "";
+  }
   return String(v);
 }
 
@@ -77,7 +81,9 @@ function scalarToStr(v: Scalar): string {
  * Scalars are wrapped in a single-element array.
  */
 function toStringArray(input: StrInput): string[] {
-  if (typeof input === "string") return [input];
+  if (typeof input === "string") {
+    return [input];
+  }
   if (input instanceof Series) {
     return input.values.map(scalarToStr);
   }
@@ -124,7 +130,9 @@ export function strNormalize(
   input: StrInput,
   form: NormalizeForm = "NFC",
 ): Series<Scalar> | string {
-  if (typeof input === "string") return input.normalize(form);
+  if (typeof input === "string") {
+    return input.normalize(form);
+  }
   const strs = toStringArray(input);
   const data: Scalar[] = strs.map((s) => s.normalize(form));
   return buildSeries(data, input);
@@ -167,7 +175,9 @@ export function strGetDummies(
   const seen = new Set<string>();
   const tokenRows: string[][] = strs.map((s) => {
     const tokens = s === "" ? [] : s.split(sep);
-    tokens.forEach((t) => seen.add(t));
+    for (const t of tokens) {
+      seen.add(t);
+    }
     return tokens;
   });
 
@@ -236,11 +246,15 @@ export function strExtractAll(
 
   const data: Scalar[] = strs.map((s) => {
     const matches: string[][] = [];
-    let m: RegExpExecArray | null;
+    let m: RegExpExecArray | null = null;
     re.lastIndex = 0;
-    while ((m = re.exec(s)) !== null) {
+    m = re.exec(s);
+    while (m !== null) {
       matches.push([...m]);
-      if (!re.global) break;
+      if (!re.global) {
+        break;
+      }
+      m = re.exec(s);
     }
     // Store as JSON string so it fits in Scalar; consumers can JSON.parse
     return JSON.stringify(matches);
@@ -272,17 +286,12 @@ export function strRemovePrefix(
   input: readonly string[] | Series<Scalar>,
   prefix: string,
 ): Series<Scalar>;
-export function strRemovePrefix(
-  input: StrInput,
-  prefix: string,
-): Series<Scalar> | string {
+export function strRemovePrefix(input: StrInput, prefix: string): Series<Scalar> | string {
   if (typeof input === "string") {
     return input.startsWith(prefix) ? input.slice(prefix.length) : input;
   }
   const strs = toStringArray(input);
-  const data: Scalar[] = strs.map((s) =>
-    s.startsWith(prefix) ? s.slice(prefix.length) : s,
-  );
+  const data: Scalar[] = strs.map((s) => (s.startsWith(prefix) ? s.slice(prefix.length) : s));
   return buildSeries(data, input);
 }
 
@@ -308,10 +317,7 @@ export function strRemoveSuffix(
   input: readonly string[] | Series<Scalar>,
   suffix: string,
 ): Series<Scalar>;
-export function strRemoveSuffix(
-  input: StrInput,
-  suffix: string,
-): Series<Scalar> | string {
+export function strRemoveSuffix(input: StrInput, suffix: string): Series<Scalar> | string {
   if (typeof input === "string") {
     return input.endsWith(suffix) ? input.slice(0, input.length - suffix.length) : input;
   }
@@ -356,7 +362,9 @@ export function strTranslate(
     for (const ch of s) {
       if (table.has(ch)) {
         const repl = table.get(ch);
-        if (repl !== null && repl !== undefined) result += repl;
+        if (repl !== null && repl !== undefined) {
+          result += repl;
+        }
         // null → delete: skip
       } else {
         result += ch;
@@ -365,7 +373,9 @@ export function strTranslate(
     return result;
   };
 
-  if (typeof input === "string") return translate(input);
+  if (typeof input === "string") {
+    return translate(input);
+  }
   const strs = toStringArray(input);
   const data: Scalar[] = strs.map(translate);
   return buildSeries(data, input);
@@ -390,12 +400,8 @@ export function strTranslate(
  * ```
  */
 export function strCharWidth(input: string): number;
-export function strCharWidth(
-  input: readonly string[] | Series<Scalar>,
-): Series<Scalar>;
-export function strCharWidth(
-  input: StrInput,
-): Series<Scalar> | number {
+export function strCharWidth(input: readonly string[] | Series<Scalar>): Series<Scalar>;
+export function strCharWidth(input: StrInput): Series<Scalar> | number {
   const width = (s: string): number => {
     let w = 0;
     for (const ch of s) {
@@ -429,7 +435,9 @@ export function strCharWidth(
     return w;
   };
 
-  if (typeof input === "string") return width(input);
+  if (typeof input === "string") {
+    return width(input);
+  }
   const strs = toStringArray(input);
   const data: Scalar[] = strs.map((s) => width(s));
   return buildSeries(data, input);
@@ -453,15 +461,13 @@ export function strCharWidth(
  * ```
  */
 export function strByteLength(input: string): number;
-export function strByteLength(
-  input: readonly string[] | Series<Scalar>,
-): Series<Scalar>;
-export function strByteLength(
-  input: StrInput,
-): Series<Scalar> | number {
+export function strByteLength(input: readonly string[] | Series<Scalar>): Series<Scalar>;
+export function strByteLength(input: StrInput): Series<Scalar> | number {
   const byteLen = (s: string): number => new TextEncoder().encode(s).length;
 
-  if (typeof input === "string") return byteLen(input);
+  if (typeof input === "string") {
+    return byteLen(input);
+  }
   const strs = toStringArray(input);
   const data: Scalar[] = strs.map((s) => byteLen(s));
   return buildSeries(data, input);
diff --git a/src/stats/string_ops_extended.ts b/src/stats/string_ops_extended.ts
index ed6e2a42..23326b2a 100644
--- a/src/stats/string_ops_extended.ts
+++ b/src/stats/string_ops_extended.ts
@@ -17,7 +17,7 @@
  * @module
  */
 
-import { DataFrame, Index, RangeIndex, Series } from "../core/index.ts";
+import { DataFrame, type Index, RangeIndex, Series } from "../core/index.ts";
 import type { Label, Scalar } from "../types.ts";
 import type { StrInput } from "./string_ops.ts";
 
@@ -74,7 +74,9 @@ export function strSplitExpand(
   const maxSplits = options.n ?? -1;
 
   function splitOne(s: string | null): (string | null)[] {
-    if (s === null) return [null];
+    if (s === null) {
+      return [null];
+    }
     if (maxSplits < 0) {
       // unlimited splits
       const pat = sep instanceof RegExp ? sep : new RegExp(escapeRegex(sep));
@@ -91,11 +93,15 @@ export function strSplitExpand(
         sepLen = sep.length;
       } else {
         const m = rest.match(sep);
-        if (m === null || m.index === undefined) break;
+        if (m === null || m.index === undefined) {
+          break;
+        }
         idx = m.index;
         sepLen = m[0]?.length ?? 0;
       }
-      if (idx === -1) break;
+      if (idx === -1) {
+        break;
+      }
       parts.push(rest.slice(0, idx));
       rest = rest.slice(idx + sepLen);
     }
@@ -164,18 +170,27 @@ export function strExtractGroups(
   const groupNames = extractGroupNames(re);
   const vals = toValues(input);
 
+  // Determine number of capture groups by adding an empty-string alternative.
+  // This always matches, and (matchResult.length - 1) gives the group count.
+  const groupCountMatch = new RegExp(`${re.source}|`).exec("");
+  const groupCount = groupCountMatch !== null ? groupCountMatch.length - 1 : 0;
+
   const rows: (string | null)[][] = vals.map((v) => {
     const s = toStrOrNull(v);
-    if (s === null) return [];
+    if (s === null) {
+      return Array.from({ length: groupCount }, (): null => null);
+    }
     const m = re.exec(s);
-    if (m === null) return [];
+    if (m === null) {
+      return Array.from({ length: groupCount }, (): null => null);
+    }
     return Array.from({ length: m.length - 1 }, (_, i) => {
       const captured = m[i + 1];
       return captured !== undefined ? captured : null;
     });
   });
 
-  const width = rows.reduce((w, r) => Math.max(w, r.length), 0);
+  const width = groupCount;
 
   // Use named groups if available and count matches; otherwise use 0-indexed strings.
   const colNames: string[] =
@@ -198,12 +213,15 @@ export function strExtractGroups(
 
 /** Parse named capture group names from a regex source string. */
 function extractGroupNames(re: RegExp): string[] {
-  const namedGroupPattern = /\(\?<([^>]+)>/g;
+  // Match named capture groups: (?<name>...)
+  // Limit group name length to 64 chars to avoid polynomial ReDoS.
+  const matches = re.source.matchAll(/\(\?<([^>]{1,64})>/g);
   const names: string[] = [];
-  let m: RegExpExecArray | null;
-  while ((m = namedGroupPattern.exec(re.source)) !== null) {
+  for (const m of matches) {
     const name = m[1];
-    if (name !== undefined) names.push(name);
+    if (name !== undefined) {
+      names.push(name);
+    }
   }
   return names;
 }
@@ -219,19 +237,17 @@ export type PartitionResult = [string, string, string];
 /** Partition a scalar string at the first occurrence of `sep`. */
 export function strPartition(input: string, sep: string): PartitionResult;
 /** Partition each element and expand to a DataFrame with columns `"0"`, `"1"`, `"2"`. */
-export function strPartition(
-  input: readonly Scalar[] | Series<Scalar>,
-  sep: string,
-): DataFrame;
+export function strPartition(input: readonly Scalar[] | Series<Scalar>, sep: string): DataFrame;
 /** @internal */
-export function strPartition(
-  input: StrInput,
-  sep: string,
-): PartitionResult | DataFrame {
+export function strPartition(input: StrInput, sep: string): PartitionResult | DataFrame {
   function partitionOne(s: string | null): [string | null, string | null, string | null] {
-    if (s === null) return [null, null, null];
+    if (s === null) {
+      return [null, null, null];
+    }
     const idx = s.indexOf(sep);
-    if (idx === -1) return [s, "", ""];
+    if (idx === -1) {
+      return [s, "", ""];
+    }
     return [s.slice(0, idx), sep, s.slice(idx + sep.length)];
   }
 
@@ -257,19 +273,17 @@ export function strPartition(
 /** Partition a scalar string at the LAST occurrence of `sep`. */
 export function strRPartition(input: string, sep: string): PartitionResult;
 /** Partition each element at the last occurrence and expand to a DataFrame. */
-export function strRPartition(
-  input: readonly Scalar[] | Series<Scalar>,
-  sep: string,
-): DataFrame;
+export function strRPartition(input: readonly Scalar[] | Series<Scalar>, sep: string): DataFrame;
 /** @internal */
-export function strRPartition(
-  input: StrInput,
-  sep: string,
-): PartitionResult | DataFrame {
+export function strRPartition(input: StrInput, sep: string): PartitionResult | DataFrame {
   function rpartitionOne(s: string | null): [string | null, string | null, string | null] {
-    if (s === null) return [null, null, null];
+    if (s === null) {
+      return [null, null, null];
+    }
     const idx = s.lastIndexOf(sep);
-    if (idx === -1) return ["", "", s];
+    if (idx === -1) {
+      return ["", "", s];
+    }
     return [s.slice(0, idx), sep, s.slice(idx + sep.length)];
   }
 
@@ -313,10 +327,15 @@ export function strMultiReplace(
   replacements: readonly ReplacePair[],
 ): string | Series<Scalar> {
   function applyAll(s: string | null): string | null {
-    if (s === null) return null;
+    if (s === null) {
+      return null;
+    }
     let result = s;
     for (const { pat, repl } of replacements) {
-      result = result.replace(pat instanceof RegExp ? pat : new RegExp(escapeRegex(pat), "g"), repl);
+      result = result.replace(
+        pat instanceof RegExp ? pat : new RegExp(escapeRegex(pat), "g"),
+        repl,
+      );
     }
     return result;
   }
@@ -361,7 +380,9 @@ export function strIndent(
   const predicate = options.predicate ?? ((line: string) => line.trim().length > 0);
 
   function indentOne(s: string | null): string | null {
-    if (s === null) return null;
+    if (s === null) {
+      return null;
+    }
     return s
       .split("\n")
       .map((line) => (predicate(line) ? prefix + line : line))
@@ -401,19 +422,25 @@ export function strDedent(input: readonly Scalar[] | Series<Scalar>): Series<Sca
 /** @internal */
 export function strDedent(input: StrInput): string | Series<Scalar> {
   function dedentOne(s: string | null): string | null {
-    if (s === null) return null;
+    if (s === null) {
+      return null;
+    }
     const lines = s.split("\n");
     // find the minimum leading-whitespace length among non-whitespace-only lines
-    let minIndent = Infinity;
+    let minIndent = Number.POSITIVE_INFINITY;
     for (const line of lines) {
-      if (line.trim().length === 0) continue;
+      if (line.trim().length === 0) {
+        continue;
+      }
       const leading = line.length - line.trimStart().length;
-      if (leading < minIndent) minIndent = leading;
+      if (leading < minIndent) {
+        minIndent = leading;
+      }
     }
-    if (minIndent === Infinity || minIndent === 0) return s;
-    return lines
-      .map((line) => (line.trim().length === 0 ? "" : line.slice(minIndent)))
-      .join("\n");
+    if (minIndent === Number.POSITIVE_INFINITY || minIndent === 0) {
+      return s;
+    }
+    return lines.map((line) => (line.trim().length === 0 ? "" : line.slice(minIndent))).join("\n");
   }
 
   if (typeof input === "string") {
diff --git a/src/stats/where_mask.ts b/src/stats/where_mask.ts
index d6921cd9..dcc53410 100644
--- a/src/stats/where_mask.ts
+++ b/src/stats/where_mask.ts
@@ -74,10 +74,7 @@ export interface DataFrameWhereOptions {
  * For a label-aligned `Series<boolean>`, labels that are absent in the target
  * series are treated as `false`.
  */
-function resolveSeriesCond(
-  series: Series<Scalar>,
-  cond: SeriesCond,
-): readonly boolean[] {
+function resolveSeriesCond(series: Series<Scalar>, cond: SeriesCond): readonly boolean[] {
   if (typeof cond === "function") {
     const resolved = cond(series);
     return resolveSeriesCond(series, resolved);
@@ -92,7 +89,9 @@ function resolveSeriesCond(
   const labels = series.index.values as readonly Label[];
   return labels.map((label) => {
     const pos = boolSeries.index.values.indexOf(label);
-    if (pos === -1) return false;
+    if (pos === -1) {
+      return false;
+    }
     const v = boolSeries.values[pos];
     return v === true;
   });
@@ -181,27 +180,29 @@ export function seriesMask(
  * For a label-aligned boolean `DataFrame`, missing column/row labels are treated
  * as `false`.
  */
-function resolveDataFrameCond(
-  df: DataFrame,
-  cond: DataFrameCond,
-): Map<string, readonly boolean[]> {
+function resolveDataFrameCond(df: DataFrame, cond: DataFrameCond): Map<string, readonly boolean[]> {
   const condDf: DataFrame = typeof cond === "function" ? cond(df) : cond;
 
   const result = new Map<string, readonly boolean[]>();
   const rowLabels = df.index.values as readonly Label[];
 
   for (const colName of df.columns.values) {
-    const condColIdx = condDf.columns.indexOf(colName);
+    const condColIdx = condDf.columns.values.indexOf(colName);
     if (condColIdx === -1) {
       // Column absent from condition → treat entire column as false
-      result.set(colName, rowLabels.map(() => false));
+      result.set(
+        colName,
+        rowLabels.map(() => false),
+      );
       continue;
     }
 
     const condCol = condDf.col(colName);
     const rowMask: boolean[] = rowLabels.map((label) => {
       const rowPos = condDf.index.values.indexOf(label);
-      if (rowPos === -1) return false;
+      if (rowPos === -1) {
+        return false;
+      }
       return condCol.values[rowPos] === true;
     });
     result.set(colName, rowMask);
diff --git a/src/stats/window_extended.ts b/src/stats/window_extended.ts
index 3811122d..6a58efce 100644
--- a/src/stats/window_extended.ts
+++ b/src/stats/window_extended.ts
@@ -113,7 +113,7 @@ function applyWindow(
   minN: number,
   agg: (nums: number[], n: number) => Scalar,
 ): SeriesLike {
-  const { values, index, name } = series;
+  const { values, name } = series;
   const n = values.length;
   const minPeriods = opts.minPeriods ?? window;
   const effectiveMin = Math.max(minN, minPeriods);
@@ -153,7 +153,11 @@ function applyWindow(
  * rollingSem(s, 3); // [null, null, ~0.577, ~0.577, ~0.577]
  * ```
  */
-export function rollingSem(series: SeriesLike, window: number, opts: WindowExtOptions = {}): SeriesLike {
+export function rollingSem(
+  series: SeriesLike,
+  window: number,
+  opts: WindowExtOptions = {},
+): SeriesLike {
   return applyWindow(series, window, opts, 2, (nums) => {
     const s = numStd(nums, 1);
     return s / Math.sqrt(nums.length);
@@ -185,7 +189,11 @@ export function rollingSem(series: SeriesLike, window: number, opts: WindowExtOp
  * rollingSkew(s, 3); // [null, null, 0, 0, 0]  (symmetric windows)
  * ```
  */
-export function rollingSkew(series: SeriesLike, window: number, opts: WindowExtOptions = {}): SeriesLike {
+export function rollingSkew(
+  series: SeriesLike,
+  window: number,
+  opts: WindowExtOptions = {},
+): SeriesLike {
   return applyWindow(series, window, opts, 3, (nums, n) => {
     const m = numMean(nums);
     const s = numStd(nums, 1);
@@ -223,7 +231,11 @@ export function rollingSkew(series: SeriesLike, window: number, opts: WindowExtO
  * rollingKurt(s, 4); // [null, null, null, -1.2]  (uniform distribution)
  * ```
  */
-export function rollingKurt(series: SeriesLike, window: number, opts: WindowExtOptions = {}): SeriesLike {
+export function rollingKurt(
+  series: SeriesLike,
+  window: number,
+  opts: WindowExtOptions = {},
+): SeriesLike {
   return applyWindow(series, window, opts, 4, (nums, n) => {
     const m = numMean(nums);
     const s = numStd(nums, 1);
@@ -231,7 +243,7 @@ export function rollingKurt(series: SeriesLike, window: number, opts: WindowExtO
       return 0;
     }
     const sum4 = nums.reduce((acc, v) => acc + ((v - m) / s) ** 4, 0);
-    const term1 = (n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3)) * sum4;
+    const term1 = ((n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))) * sum4;
     const term2 = (3 * (n - 1) ** 2) / ((n - 2) * (n - 3));
     return term1 - term2;
   });
@@ -274,7 +286,6 @@ function computeQuantile(
       const fracLo = virtual - lo;
       return fracLo < 0.5 ? loVal : hiVal;
     }
-    case "linear":
     default: {
       const frac = virtual - lo;
       return loVal + frac * (hiVal - loVal);
diff --git a/src/window/rolling_apply.ts b/src/window/rolling_apply.ts
index 18d09c93..63c23b8a 100644
--- a/src/window/rolling_apply.ts
+++ b/src/window/rolling_apply.ts
@@ -27,7 +27,7 @@
  */
 
 import { DataFrame } from "../core/index.ts";
-import { Index } from "../core/index.ts";
+import type { Index } from "../core/index.ts";
 import { Series } from "../core/index.ts";
 import type { Label, Scalar } from "../types.ts";
 
@@ -82,8 +82,12 @@ function validNums(slice: readonly Scalar[]): number[] {
 /** Convert a raw window slice to `null`-substituted numeric array. */
 function rawWindow(slice: readonly Scalar[]): (number | null)[] {
   return slice.map((v): number | null => {
-    if (isMissing(v)) return null;
-    if (typeof v === "number") return v;
+    if (isMissing(v)) {
+      return null;
+    }
+    if (typeof v === "number") {
+      return v;
+    }
     return null;
   });
 }
@@ -172,9 +176,7 @@ export function rollingApply(
     if (!met) {
       result.push(null);
     } else if (useRaw) {
-      const validOnly = (raw as readonly (number | null)[]).filter(
-        (v): v is number => v !== null,
-      );
+      const validOnly = (raw as readonly (number | null)[]).filter((v): v is number => v !== null);
       result.push(fn(validOnly));
     } else {
       result.push(fn(nums));
diff --git a/tests/core/api_types.test.ts b/tests/core/api_types.test.ts
index 17064ceb..94a7a6cd 100644
--- a/tests/core/api_types.test.ts
+++ b/tests/core/api_types.test.ts
@@ -3,7 +3,6 @@
  */
 import { describe, expect, it } from "bun:test";
 import fc from "fast-check";
-import { Dtype } from "../../src/index.ts";
 import {
   isArrayLike,
   isBigInt,
@@ -28,8 +27,8 @@ import {
   isNumericDtype,
   isObjectDtype,
   isPeriodDtype,
-  isRegExp,
   isReCompilable,
+  isRegExp,
   isScalar,
   isSignedIntegerDtype,
   isStringDtype,
@@ -37,6 +36,7 @@ import {
   isTimedeltaDtype,
   isUnsignedIntegerDtype,
 } from "../../src/core/api_types.ts";
+import { Dtype } from "../../src/index.ts";
 
 // ─── isScalar ─────────────────────────────────────────────────────────────────
 
@@ -73,9 +73,7 @@ describe("isScalar", () => {
   });
 
   it("property: all numbers are scalars", () => {
-    fc.assert(
-      fc.property(fc.float({ noNaN: true }), (n) => isScalar(n) === true),
-    );
+    fc.assert(fc.property(fc.float({ noNaN: true }), (n) => isScalar(n) === true));
   });
 });
 
@@ -127,7 +125,7 @@ describe("isArrayLike", () => {
 
   it("returns false for numbers", () => {
     expect(isArrayLike(42)).toBe(false);
-    expect(isArrayLike(NaN)).toBe(false);
+    expect(isArrayLike(Number.NaN)).toBe(false);
   });
 
   it("returns false for null/undefined", () => {
@@ -206,9 +204,9 @@ describe("isNumber", () => {
   it("true for numbers including NaN and Infinity", () => {
     expect(isNumber(3.14)).toBe(true);
     expect(isNumber(0)).toBe(true);
-    expect(isNumber(NaN)).toBe(true);
-    expect(isNumber(Infinity)).toBe(true);
-    expect(isNumber(-Infinity)).toBe(true);
+    expect(isNumber(Number.NaN)).toBe(true);
+    expect(isNumber(Number.POSITIVE_INFINITY)).toBe(true);
+    expect(isNumber(Number.NEGATIVE_INFINITY)).toBe(true);
   });
 
   it("false for non-numbers", () => {
@@ -256,9 +254,9 @@ describe("isFloat", () => {
   });
 
   it("false for NaN and Infinity", () => {
-    expect(isFloat(NaN)).toBe(false);
-    expect(isFloat(Infinity)).toBe(false);
-    expect(isFloat(-Infinity)).toBe(false);
+    expect(isFloat(Number.NaN)).toBe(false);
+    expect(isFloat(Number.POSITIVE_INFINITY)).toBe(false);
+    expect(isFloat(Number.NEGATIVE_INFINITY)).toBe(false);
   });
 
   it("false for non-numbers", () => {
@@ -279,8 +277,8 @@ describe("isInteger", () => {
   });
 
   it("false for NaN and Infinity", () => {
-    expect(isInteger(NaN)).toBe(false);
-    expect(isInteger(Infinity)).toBe(false);
+    expect(isInteger(Number.NaN)).toBe(false);
+    expect(isInteger(Number.POSITIVE_INFINITY)).toBe(false);
   });
 
   it("false for non-numbers", () => {
@@ -305,7 +303,7 @@ describe("isBigInt", () => {
 describe("isRegExp", () => {
   it("true for RegExp instances", () => {
     expect(isRegExp(/abc/)).toBe(true);
-    expect(isRegExp(new RegExp("xyz"))).toBe(true);
+    expect(isRegExp(/xyz/)).toBe(true);
   });
 
   it("false for strings and other values", () => {
@@ -332,20 +330,22 @@ describe("isMissing", () => {
   it("true for null, undefined, NaN", () => {
     expect(isMissing(null)).toBe(true);
     expect(isMissing(undefined)).toBe(true);
-    expect(isMissing(NaN)).toBe(true);
+    expect(isMissing(Number.NaN)).toBe(true);
   });
 
   it("false for valid values", () => {
     expect(isMissing(0)).toBe(false);
     expect(isMissing("")).toBe(false);
     expect(isMissing(false)).toBe(false);
-    expect(isMissing(Infinity)).toBe(false);
+    expect(isMissing(Number.POSITIVE_INFINITY)).toBe(false);
   });
 
   it("property: no finite number is missing", () => {
     fc.assert(
       fc.property(fc.float({ noNaN: true }), (n) => {
-        if (!Number.isFinite(n)) return true;
+        if (!Number.isFinite(n)) {
+          return true;
+        }
         return !isMissing(n);
       }),
     );
@@ -388,7 +388,18 @@ describe("isDate", () => {
 
 describe("isNumericDtype", () => {
   it("true for all numeric dtypes", () => {
-    for (const name of ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "float32", "float64"] as const) {
+    for (const name of [
+      "int8",
+      "int16",
+      "int32",
+      "int64",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "float32",
+      "float64",
+    ] as const) {
       expect(isNumericDtype(name)).toBe(true);
       expect(isNumericDtype(Dtype.from(name))).toBe(true);
     }
@@ -575,8 +586,26 @@ describe("isIntervalDtype", () => {
 // ─── property-based cross-checks ─────────────────────────────────────────────
 
 describe("dtype predicate cross-checks", () => {
-  const numericNames = ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "float32", "float64"] as const;
-  const nonNumericNames = ["bool", "string", "object", "datetime", "timedelta", "category"] as const;
+  const numericNames = [
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "float32",
+    "float64",
+  ] as const;
+  const nonNumericNames = [
+    "bool",
+    "string",
+    "object",
+    "datetime",
+    "timedelta",
+    "category",
+  ] as const;
 
   it("isNumericDtype and isIntegerDtype are consistent", () => {
     for (const n of numericNames) {
diff --git a/tests/core/attrs.test.ts b/tests/core/attrs.test.ts
index 8a22786b..9281623b 100644
--- a/tests/core/attrs.test.ts
+++ b/tests/core/attrs.test.ts
@@ -38,7 +38,6 @@
 
 import { describe, expect, test } from "bun:test";
 import * as fc from "fast-check";
-import { DataFrame, Series } from "../../src/index.ts";
 import {
   attrsCount,
   attrsKeys,
@@ -54,6 +53,7 @@ import {
   updateAttrs,
   withAttrs,
 } from "../../src/core/attrs.ts";
+import { DataFrame, Series } from "../../src/index.ts";
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
@@ -485,7 +485,10 @@ describe("property: setAttrs/getAttrs round-trip", () => {
   test("any record can be stored and retrieved intact", () => {
     fc.assert(
       fc.property(
-        fc.dictionary(fc.string({ minLength: 1, maxLength: 10 }), fc.oneof(fc.integer(), fc.string(), fc.boolean())),
+        fc.dictionary(
+          fc.string({ minLength: 1, maxLength: 10 }),
+          fc.oneof(fc.integer(), fc.string(), fc.boolean()),
+        ),
         (attrs) => {
           const obj = freshObj();
           setAttrs(obj, attrs);
diff --git a/tests/core/insert_pop.test.ts b/tests/core/insert_pop.test.ts
index daab7705..7c74d6b2 100644
--- a/tests/core/insert_pop.test.ts
+++ b/tests/core/insert_pop.test.ts
@@ -20,8 +20,8 @@
 
 import { describe, expect, test } from "bun:test";
 import * as fc from "fast-check";
-import { DataFrame, Series } from "../../src/index.ts";
 import { insertColumn, moveColumn, popColumn, reorderColumns } from "../../src/core/insert_pop.ts";
+import { DataFrame, Series } from "../../src/index.ts";
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
diff --git a/tests/core/pipe_apply.test.ts b/tests/core/pipe_apply.test.ts
index 9ebee428..b024f96d 100644
--- a/tests/core/pipe_apply.test.ts
+++ b/tests/core/pipe_apply.test.ts
@@ -114,19 +114,13 @@ describe("pipe", () => {
 
   test("works with Series", () => {
     const s = makeSeries([1, 2, 3]);
-    const result = pipe(
-      s,
-      (s2: Series<Scalar>) => s2.sum(),
-    );
+    const result = pipe(s, (s2: Series<Scalar>) => s2.sum());
     expect(result).toBe(6);
   });
 
   test("works with DataFrame", () => {
     const df = makeDF({ a: [1, 2], b: [3, 4] });
-    const result = pipe(
-      df,
-      (d: DataFrame) => d.sum(),
-    );
+    const result = pipe(df, (d: DataFrame) => d.sum());
     expect(result.at("a")).toBe(3);
     expect(result.at("b")).toBe(7);
   });
@@ -135,8 +129,14 @@ describe("pipe", () => {
     const calls: string[] = [];
     pipe(
       10,
-      (x: number) => { calls.push(`fn1:${x}`); return x + 1; },
-      (x: number) => { calls.push(`fn2:${x}`); return x * 2; },
+      (x: number) => {
+        calls.push(`fn1:${x}`);
+        return x + 1;
+      },
+      (x: number) => {
+        calls.push(`fn2:${x}`);
+        return x * 2;
+      },
     );
     expect(calls).toEqual(["fn1:10", "fn2:11"]);
   });
@@ -181,7 +181,7 @@ describe("seriesApply", () => {
 
   test("null values are passed to fn", () => {
     const s = makeSeries([1, null, 3]);
-    const out = seriesApply(s, (v) => v === null ? 0 : (v as number) + 1);
+    const out = seriesApply(s, (v) => (v === null ? 0 : (v as number) + 1));
     expect(out.values).toEqual([2, 0, 4]);
   });
 
@@ -217,7 +217,10 @@ describe("seriesTransform", () => {
   test("fn only receives value (no label/pos)", () => {
     const callCount = { n: 0 };
     const s = makeSeries([1, 2]);
-    seriesTransform(s, (v) => { callCount.n++; return v; });
+    seriesTransform(s, (v) => {
+      callCount.n++;
+      return v;
+    });
     expect(callCount.n).toBe(2);
   });
 });
@@ -236,7 +239,10 @@ describe("dataFrameApply", () => {
 
   test("axis=0: fn receives column Series and column name", () => {
     const received: string[] = [];
-    dataFrameApply(df, (_s, name) => { received.push(name as string); return 0; });
+    dataFrameApply(df, (_s, name) => {
+      received.push(name as string);
+      return 0;
+    });
     expect(received).toEqual(["a", "b"]);
   });
 
@@ -254,7 +260,14 @@ describe("dataFrameApply", () => {
 
   test("axis=1: row Series has column names as index", () => {
     const colNames: string[][] = [];
-    dataFrameApply(df, (s) => { colNames.push([...s.index.values] as string[]); return 0; }, 1);
+    dataFrameApply(
+      df,
+      (s) => {
+        colNames.push([...s.index.values] as string[]);
+        return 0;
+      },
+      1,
+    );
     expect(colNames[0]).toEqual(["a", "b"]);
     expect(colNames[1]).toEqual(["a", "b"]);
   });
@@ -262,7 +275,14 @@ describe("dataFrameApply", () => {
   test("axis=1: fn receives row label as second arg", () => {
     const dfLabeled = makeDF({ x: [1, 2] }, ["row0", "row1"]);
     const labels: Label[] = [];
-    dataFrameApply(dfLabeled, (_s, lbl) => { labels.push(lbl); return 0; }, 1);
+    dataFrameApply(
+      dfLabeled,
+      (_s, lbl) => {
+        labels.push(lbl);
+        return 0;
+      },
+      1,
+    );
     expect(labels).toEqual(["row0", "row1"]);
   });
 
@@ -285,11 +305,16 @@ describe("dataFrameApplyMap", () => {
   });
 
   test("fn receives (value, rowLabel, colName)", () => {
-    const calls: Array<[Scalar, Label, string]> = [];
-    dataFrameApplyMap(df, (v, row, col) => { calls.push([v, row, col]); return v; });
+    const calls: [Scalar, Label, string][] = [];
+    dataFrameApplyMap(df, (v, row, col) => {
+      calls.push([v, row, col]);
+      return v;
+    });
     expect(calls).toEqual([
-      [1, "r0", "x"], [2, "r1", "x"],
-      [3, "r0", "y"], [4, "r1", "y"],
+      [1, "r0", "x"],
+      [2, "r1", "x"],
+      [3, "r0", "y"],
+      [4, "r1", "y"],
     ]);
   });
 
@@ -317,16 +342,17 @@ describe("dataFrameTransform", () => {
   const df = makeDF({ a: [1, 2, 3], b: [4, 5, 6] });
 
   test("replaces each column with fn(col)", () => {
-    const out = dataFrameTransform(df, (col) =>
-      seriesTransform(col, (v) => -(v as number)),
-    );
+    const out = dataFrameTransform(df, (col) => seriesTransform(col, (v) => -(v as number)));
     expect(out.col("a").values).toEqual([-1, -2, -3]);
     expect(out.col("b").values).toEqual([-4, -5, -6]);
   });
 
   test("fn receives (col, colName)", () => {
     const names: string[] = [];
-    dataFrameTransform(df, (col, name) => { names.push(name); return col; });
+    dataFrameTransform(df, (col, name) => {
+      names.push(name);
+      return col;
+    });
     expect(names).toEqual(["a", "b"]);
   });
 
@@ -337,9 +363,7 @@ describe("dataFrameTransform", () => {
   });
 
   test("throws RangeError when fn returns wrong length", () => {
-    expect(() =>
-      dataFrameTransform(df, (_col) => makeSeries([1])),
-    ).toThrow(RangeError);
+    expect(() => dataFrameTransform(df, (_col) => makeSeries([1]))).toThrow(RangeError);
   });
 });
 
@@ -349,7 +373,10 @@ describe("dataFrameTransformRows", () => {
   const df = makeDF({ a: [1, 2, 3], b: [10, 20, 30] });
 
   test("applies fn to each row record", () => {
-    const out = dataFrameTransformRows(df, (row) => ({ a: (row["a"] as number) + 100, b: row["b"] }));
+    const out = dataFrameTransformRows(df, (row) => ({
+      a: (row["a"] as number) + 100,
+      b: row["b"],
+    }));
     expect(out.col("a").values).toEqual([101, 102, 103]);
     expect(out.col("b").values).toEqual([10, 20, 30]);
   });
@@ -368,7 +395,7 @@ describe("dataFrameTransformRows", () => {
   });
 
   test("partial row update merges correctly (unspecified keys keep original)", () => {
-    const out = dataFrameTransformRows(df, (row) => ({ a: 999 }));
+    const out = dataFrameTransformRows(df, (_row) => ({ a: 999 }));
     // 'b' not returned by fn → keeps original
     expect(out.col("a").values).toEqual([999, 999, 999]);
     expect(out.col("b").values).toEqual([10, 20, 30]);
@@ -418,14 +445,11 @@ describe("seriesApply — property tests", () => {
 describe("seriesTransform — property tests", () => {
   test("identity fn produces identical values", () => {
     fc.assert(
-      fc.property(
-        fc.array(fc.integer(), { minLength: 0, maxLength: 20 }),
-        (data) => {
-          const s = makeSeries(data as Scalar[]);
-          const out = seriesTransform(s, (v) => v);
-          expect([...out.values]).toEqual([...s.values]);
-        },
-      ),
+      fc.property(fc.array(fc.integer(), { minLength: 0, maxLength: 20 }), (data) => {
+        const s = makeSeries(data as Scalar[]);
+        const out = seriesTransform(s, (v) => v);
+        expect([...out.values]).toEqual([...s.values]);
+      }),
     );
   });
 });
diff --git a/tests/core/to_from_dict.test.ts b/tests/core/to_from_dict.test.ts
index e842e29e..2c640b79 100644
--- a/tests/core/to_from_dict.test.ts
+++ b/tests/core/to_from_dict.test.ts
@@ -23,11 +23,8 @@
 
 import { describe, expect, test } from "bun:test";
 import * as fc from "fast-check";
+import { fromDictOriented, toDictOriented } from "../../src/core/to_from_dict.ts";
 import { DataFrame, Index, Series } from "../../src/index.ts";
-import {
-  fromDictOriented,
-  toDictOriented,
-} from "../../src/core/to_from_dict.ts";
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
@@ -36,10 +33,7 @@ function makeDF(): DataFrame {
 }
 
 function makeIndexedDF(): DataFrame {
-  return DataFrame.fromColumns(
-    { x: [10, 20], y: [30, 40] },
-    { index: new Index(["r0", "r1"]) },
-  );
+  return DataFrame.fromColumns({ x: [10, 20], y: [30, 40] }, { index: new Index(["r0", "r1"]) });
 }
 
 // ─── toDictOriented ───────────────────────────────────────────────────────────
@@ -99,14 +93,21 @@ describe("toDictOriented — split", () => {
     const result = toDictOriented(df, "split");
     expect(result.columns).toEqual(["a", "b"]);
     expect(result.index).toEqual([0, 1, 2]);
-    expect(result.data).toEqual([[1, 4], [2, 5], [3, 6]]);
+    expect(result.data).toEqual([
+      [1, 4],
+      [2, 5],
+      [3, 6],
+    ]);
   });
 
   test("split with custom index", () => {
     const df = makeIndexedDF();
     const result = toDictOriented(df, "split");
     expect(result.index).toEqual(["r0", "r1"]);
-    expect(result.data).toEqual([[10, 30], [20, 40]]);
+    expect(result.data).toEqual([
+      [10, 30],
+      [20, 40],
+    ]);
   });
 });
 
@@ -117,7 +118,11 @@ describe("toDictOriented — tight", () => {
     expect(result.index_names).toEqual([null]);
     expect(result.column_names).toEqual([null]);
     expect(result.columns).toEqual(["a", "b"]);
-    expect(result.data).toEqual([[1, 4], [2, 5], [3, 6]]);
+    expect(result.data).toEqual([
+      [1, 4],
+      [2, 5],
+      [3, 6],
+    ]);
   });
 });
 
@@ -166,10 +171,7 @@ describe("fromDictOriented — columns", () => {
 
 describe("fromDictOriented — index", () => {
   test("reconstructs from rowLabel→col→value mapping", () => {
-    const df = fromDictOriented(
-      { r0: { x: 10, y: 30 }, r1: { x: 20, y: 40 } },
-      "index",
-    );
+    const df = fromDictOriented({ r0: { x: 10, y: 30 }, r1: { x: 20, y: 40 } }, "index");
     expect(df.index.values).toEqual(["r0", "r1"]);
     expect(df.col("x").values).toEqual([10, 20]);
     expect(df.col("y").values).toEqual([30, 40]);
@@ -191,7 +193,14 @@ describe("fromDictOriented — index", () => {
 describe("fromDictOriented — split", () => {
   test("reconstructs from split structure", () => {
     const df = fromDictOriented(
-      { columns: ["a", "b"], data: [[1, 4], [2, 5], [3, 6]] },
+      {
+        columns: ["a", "b"],
+        data: [
+          [1, 4],
+          [2, 5],
+          [3, 6],
+        ],
+      },
       "split",
     );
     expect(df.shape).toEqual([3, 2]);
@@ -241,7 +250,9 @@ describe("property-based", () => {
         fc.array(fc.integer({ min: 1, max: 10 }), { minLength: 1, maxLength: 4 }),
         fc.array(fc.integer({ min: 1, max: 10 }), { minLength: 1, maxLength: 4 }),
         (colA, colB) => {
-          const df = DataFrame.fromColumns({ a: colA, b: colB.slice(0, colA.length) });
+          // Ensure both columns have the same length
+          const len = Math.min(colA.length, colB.length);
+          const df = DataFrame.fromColumns({ a: colA.slice(0, len), b: colB.slice(0, len) });
           const split = toDictOriented(df, "split");
           const df2 = fromDictOriented(split, "split");
           return df2.shape[0] === df.shape[0] && df2.columns.values[0] === "a";
diff --git a/tests/reshape/wide_to_long.test.ts b/tests/reshape/wide_to_long.test.ts
index 61d38269..59d63951 100644
--- a/tests/reshape/wide_to_long.test.ts
+++ b/tests/reshape/wide_to_long.test.ts
@@ -133,12 +133,27 @@ describe("wideToLong — multiple id columns", () => {
 // ─── missing stub column → null ───────────────────────────────────────────────
 
 describe("wideToLong — missing stub columns", () => {
-  test("missing wide column fills with null", () => {
-    // A1 exists but A2 does not — A2 values should be null
-    const df = DataFrame.fromColumns({ id: [1], A1: [10] });
-    const long = wideToLong(df, "A", "id", "n", { suffix: "[12]" });
-    // suffix 1 → A1=10, suffix 2 → A2=null
-    expect(long.col("A").values).toEqual([10, null]);
+  test("missing wide column fills with null when other stubs cover that suffix", () => {
+    // Only A1 and B2 exist — mixed stubs
+    const df = DataFrame.fromColumns({
+      id: ["x", "y"],
+      A1: [1, 2],
+      B2: [7, 8],
+    });
+    const long = wideToLong(df, ["A", "B"], "id", "t");
+    // suffix 1: A1=[1,2], B1=missing=null
+    // suffix 2: A2=missing=null, B2=[7,8]
+    expect(long.shape[0]).toBe(4); // 2 rows × 2 suffixes
+    const aVals = long.col("A").values;
+    const bVals = long.col("B").values;
+    expect(aVals[0]).toBe(1);
+    expect(aVals[1]).toBe(2);
+    expect(bVals[0]).toBeNull();
+    expect(bVals[1]).toBeNull();
+    expect(aVals[2]).toBeNull();
+    expect(aVals[3]).toBeNull();
+    expect(bVals[2]).toBe(7);
+    expect(bVals[3]).toBe(8);
   });
 });
 
@@ -200,10 +215,18 @@ describe("property-based", () => {
           const df = DataFrame.fromColumns(colData);
           const long = wideToLong(df, "v", "id", "n");
           const outId = long.col("id").values;
-          // Each original id value should appear nSuffix times
-          return idVals.every(
-            (v) => outId.filter((x) => x === v).length === nSuffix,
-          );
+          // Each original id value occurrence should appear nSuffix times total
+          const counts = new Map<number, number>();
+          for (const id of idVals) {
+            counts.set(id, (counts.get(id) ?? 0) + 1);
+          }
+          for (const [id, originalCount] of counts) {
+            const count = outId.filter((x) => x === id).length;
+            if (count !== originalCount * nSuffix) {
+              return false;
+            }
+          }
+          return true;
         },
       ),
     );
diff --git a/tests/stats/categorical_ops.test.ts b/tests/stats/categorical_ops.test.ts
index c5af01d6..7b1a5220 100644
--- a/tests/stats/categorical_ops.test.ts
+++ b/tests/stats/categorical_ops.test.ts
@@ -418,7 +418,9 @@ describe("catFromCodes — property tests", () => {
           const rebuilt = catFromCodes(codes, cats);
           const orig = s.toArray();
           const back = rebuilt.toArray();
-          if (orig.length !== back.length) return false;
+          if (orig.length !== back.length) {
+            return false;
+          }
           return orig.every((v, i) => v === back[i]);
         },
       ),
@@ -449,10 +451,7 @@ describe("catFromCodes — property tests", () => {
           const a = makeCat(va, [...new Set(va)]);
           const b = makeCat(vb, [...new Set(vb)]);
           const r = catUnionCategories(a, b);
-          return (
-            r.cat.nCategories >= a.cat.nCategories &&
-            r.cat.nCategories >= b.cat.nCategories
-          );
+          return r.cat.nCategories >= a.cat.nCategories && r.cat.nCategories >= b.cat.nCategories;
         },
       ),
     );
diff --git a/tests/stats/cut_qcut.test.ts b/tests/stats/cut_qcut.test.ts
index 10da91df..a392a241 100644
--- a/tests/stats/cut_qcut.test.ts
+++ b/tests/stats/cut_qcut.test.ts
@@ -24,10 +24,10 @@ describe("cut — integer bins", () => {
 
   it("right=false uses left-closed intervals", () => {
     const { codes, labels } = cut([1, 2, 3, 4, 5], 2, { right: false });
-    // [lo, hi)
+    // [lo, hi) — bin 0 is [min-ε, 3), bin 1 is [3, 5]
     expect(labels[0]).toMatch(/^\[/);
     expect(labels[0]).toMatch(/\)$/);
-    expect(codes).toEqual([0, 0, 0, 1, 1]);
+    expect(codes).toEqual([0, 0, 1, 1, 1]);
   });
 
   it("include_lowest labels the first bin with [ on both sides", () => {
@@ -203,17 +203,19 @@ describe("cut — property tests", () => {
         (xs, numBins) => {
           // Need at least 2 distinct finite values
           const distinct = new Set(xs.filter(Number.isFinite));
-          if (distinct.size < 2) return;
+          if (distinct.size < 2) {
+            return;
+          }
           const { codes, labels } = cut(xs, numBins, { include_lowest: true });
           for (let i = 0; i < xs.length; i++) {
             const v = xs[i] as number;
             const c = codes[i];
-            if (!Number.isFinite(v)) {
-              expect(c).toBeNull();
-            } else {
+            if (Number.isFinite(v)) {
               expect(c).not.toBeNull();
               expect(c).toBeGreaterThanOrEqual(0);
               expect(c).toBeLessThan(labels.length);
+            } else {
+              expect(c).toBeNull();
             }
           }
         },
@@ -231,7 +233,9 @@ describe("cut — property tests", () => {
         fc.integer({ min: 2, max: 4 }),
         (xs, numBins) => {
           const distinct = new Set(xs.filter(Number.isFinite));
-          if (distinct.size < 2) return;
+          if (distinct.size < 2) {
+            return;
+          }
           const { codes } = cut(xs, numBins);
           expect(codes.length).toBe(xs.length);
         },
@@ -252,19 +256,21 @@ describe("qcut — property tests", () => {
         (xs, numQ) => {
           const finite = xs.filter(Number.isFinite);
           const distinct = new Set(finite);
-          if (distinct.size < numQ) return;
+          if (distinct.size < numQ) {
+            return;
+          }
           try {
             const { codes, labels } = qcut(xs, numQ, { duplicates: "drop" });
             for (let i = 0; i < xs.length; i++) {
               const v = xs[i] as number;
               const c = codes[i];
-              if (!Number.isFinite(v)) {
-                expect(c).toBeNull();
-              } else {
+              if (Number.isFinite(v)) {
                 if (c !== null) {
                   expect(c).toBeGreaterThanOrEqual(0);
                   expect(c).toBeLessThan(labels.length);
                 }
+              } else {
+                expect(c).toBeNull();
               }
             }
           } catch {
diff --git a/tests/stats/format_ops.test.ts b/tests/stats/format_ops.test.ts
index fee43e8c..5ef52a2d 100644
--- a/tests/stats/format_ops.test.ts
+++ b/tests/stats/format_ops.test.ts
@@ -27,7 +27,7 @@ import {
 
 describe("formatFloat", () => {
   test("default 2 decimal places", () => {
-    expect(formatFloat(3.14159)).toBe("3.14");
+    expect(formatFloat(Math.PI)).toBe("3.14");
   });
 
   test("0 decimal places", () => {
@@ -47,7 +47,7 @@ describe("formatFloat", () => {
   });
 
   test("Infinity", () => {
-    expect(formatFloat(Infinity)).toBe("Infinity");
+    expect(formatFloat(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -100,7 +100,7 @@ describe("formatPercent", () => {
   });
 
   test("Infinity", () => {
-    expect(formatPercent(Infinity)).toBe("Infinity");
+    expect(formatPercent(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -129,7 +129,7 @@ describe("formatScientific", () => {
   });
 
   test("Infinity", () => {
-    expect(formatScientific(Infinity)).toBe("Infinity");
+    expect(formatScientific(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -138,9 +138,12 @@ describe("formatScientific", () => {
 
   test("property: contains e", () => {
     fc.assert(
-      fc.property(fc.double({ noNaN: true, noDefaultInfinity: true, min: 1e-100, max: 1e100 }), (n) => {
-        return formatScientific(n).includes("e");
-      }),
+      fc.property(
+        fc.double({ noNaN: true, noDefaultInfinity: true, min: 1e-100, max: 1e100 }),
+        (n) => {
+          return formatScientific(n).includes("e");
+        },
+      ),
     );
   });
 });
@@ -170,7 +173,7 @@ describe("formatEngineering", () => {
   });
 
   test("Infinity", () => {
-    expect(formatEngineering(Infinity)).toBe("Infinity");
+    expect(formatEngineering(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -179,17 +182,18 @@ describe("formatEngineering", () => {
 
   test("property: exponent is multiple of 3", () => {
     fc.assert(
-      fc.property(
-        fc.double({ noNaN: true, noDefaultInfinity: true, min: 1e-9, max: 1e9 }),
-        (n) => {
-          if (n === 0) return true;
-          const result = formatEngineering(n);
-          const match = result.match(/e([+-])(\d+)$/);
-          if (!match) return false;
-          const exp = Number(match[2]);
-          return exp % 3 === 0;
-        },
-      ),
+      fc.property(fc.double({ noNaN: true, noDefaultInfinity: true, min: 1e-9, max: 1e9 }), (n) => {
+        if (n === 0) {
+          return true;
+        }
+        const result = formatEngineering(n);
+        const match = result.match(/e([+-])(\d+)$/);
+        if (!match) {
+          return false;
+        }
+        const exp = Number(match[2]);
+        return exp % 3 === 0;
+      }),
     );
   });
 });
@@ -218,7 +222,7 @@ describe("formatThousands", () => {
   });
 
   test("Infinity", () => {
-    expect(formatThousands(Infinity)).toBe("Infinity");
+    expect(formatThousands(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -246,7 +250,7 @@ describe("formatCurrency", () => {
   });
 
   test("Infinity", () => {
-    expect(formatCurrency(Infinity)).toBe("$Infinity");
+    expect(formatCurrency(Number.POSITIVE_INFINITY)).toBe("$Infinity");
   });
 
   test("NaN", () => {
@@ -286,7 +290,7 @@ describe("formatCompact", () => {
   });
 
   test("Infinity", () => {
-    expect(formatCompact(Infinity)).toBe("Infinity");
+    expect(formatCompact(Number.POSITIVE_INFINITY)).toBe("Infinity");
   });
 
   test("NaN", () => {
@@ -299,7 +303,7 @@ describe("formatCompact", () => {
 describe("makeFloatFormatter", () => {
   test("basic usage", () => {
     const fmt = makeFloatFormatter(3);
-    expect(fmt(3.14159)).toBe("3.142");
+    expect(fmt(Math.PI)).toBe("3.142");
   });
 
   test("non-numeric value", () => {
@@ -557,7 +561,10 @@ describe("dataFrameToString", () => {
   test("returns a string", () => {
     fc.assert(
       fc.property(
-        fc.array(fc.double({ noNaN: true, noDefaultInfinity: true }), { minLength: 1, maxLength: 20 }),
+        fc.array(fc.double({ noNaN: true, noDefaultInfinity: true }), {
+          minLength: 1,
+          maxLength: 20,
+        }),
         (vals) => {
           const df = DataFrame.fromColumns({ x: vals, y: vals });
           return typeof dataFrameToString(df) === "string";
diff --git a/tests/stats/notna_isna.test.ts b/tests/stats/notna_isna.test.ts
index 22a78b53..140db6e9 100644
--- a/tests/stats/notna_isna.test.ts
+++ b/tests/stats/notna_isna.test.ts
@@ -39,7 +39,7 @@ describe("isna — scalar", () => {
   });
 
   it("returns true for NaN", () => {
-    expect(isna(NaN)).toBe(true);
+    expect(isna(Number.NaN)).toBe(true);
   });
 
   it("returns false for 0", () => {
@@ -75,7 +75,7 @@ describe("isna — scalar", () => {
 
 describe("isna — array", () => {
   it("maps correctly over mixed array", () => {
-    expect(isna([1, null, NaN, "x", undefined])).toEqual([false, true, true, false, true]);
+    expect(isna([1, null, Number.NaN, "x", undefined])).toEqual([false, true, true, false, true]);
   });
 
   it("returns all-false for array with no missing values", () => {
@@ -95,7 +95,7 @@ describe("isna — array", () => {
 
 describe("isna — Series", () => {
   it("returns boolean Series with true at missing positions", () => {
-    const result = isna(s([1, null, NaN, 4]));
+    const result = isna(s([1, null, Number.NaN, 4]));
     expect(sv(result)).toEqual([false, true, true, false]);
   });
 
@@ -110,7 +110,7 @@ describe("isna — Series", () => {
   });
 
   it("handles all-missing series", () => {
-    const result = isna(s([null, undefined, NaN]));
+    const result = isna(s([null, undefined, Number.NaN]));
     expect(sv(result)).toEqual([true, true, true]);
   });
 });
@@ -122,7 +122,7 @@ describe("isna — DataFrame", () => {
     const df = new DataFrame(
       new Map([
         ["a", s([1, null, 3]) as Series<Scalar>],
-        ["b", s([NaN, 5, null]) as Series<Scalar>],
+        ["b", s([Number.NaN, 5, null]) as Series<Scalar>],
       ]),
     );
     const result = isna(df);
@@ -155,7 +155,7 @@ describe("notna — scalar", () => {
   });
 
   it("returns false for NaN", () => {
-    expect(notna(NaN)).toBe(false);
+    expect(notna(Number.NaN)).toBe(false);
   });
 
   it("returns true for 0", () => {
@@ -179,7 +179,7 @@ describe("notna — scalar", () => {
 
 describe("notna — array", () => {
   it("is the inverse of isna for arrays", () => {
-    const arr: Scalar[] = [1, null, NaN, "x", undefined];
+    const arr: Scalar[] = [1, null, Number.NaN, "x", undefined];
     const naFlags = isna(arr);
     const notnaFlags = notna(arr);
     for (let i = 0; i < arr.length; i++) {
@@ -192,7 +192,7 @@ describe("notna — array", () => {
 
 describe("notna — Series", () => {
   it("is the inverse of isna for Series", () => {
-    const series = s([1, null, NaN, 4]);
+    const series = s([1, null, Number.NaN, 4]);
     const naResult = isna(series);
     const notnaResult = notna(series);
     for (let i = 0; i < series.values.length; i++) {
@@ -207,7 +207,7 @@ describe("isnull / notnull — aliases", () => {
   it("isnull(scalar) matches isna(scalar)", () => {
     expect(isnull(null)).toBe(isna(null));
     expect(isnull(1)).toBe(isna(1));
-    expect(isnull(NaN)).toBe(isna(NaN));
+    expect(isnull(Number.NaN)).toBe(isna(Number.NaN));
   });
 
   it("notnull(scalar) matches notna(scalar)", () => {
@@ -216,7 +216,7 @@ describe("isnull / notnull — aliases", () => {
   });
 
   it("isnull(array) matches isna(array)", () => {
-    const arr: Scalar[] = [1, null, NaN];
+    const arr: Scalar[] = [1, null, Number.NaN];
     expect(isnull(arr)).toEqual(isna(arr));
   });
 
@@ -226,9 +226,7 @@ describe("isnull / notnull — aliases", () => {
   });
 
   it("isnull(DataFrame) matches isna(DataFrame) column values", () => {
-    const df = new DataFrame(
-      new Map([["a", s([null, 1, NaN]) as Series<Scalar>]]),
-    );
+    const df = new DataFrame(new Map([["a", s([null, 1, Number.NaN]) as Series<Scalar>]]));
     const r1 = isnull(df);
     const r2 = isna(df);
     expect(sv(r1.col("a"))).toEqual(sv(r2.col("a")));
@@ -247,7 +245,7 @@ describe("fillna — scalar", () => {
   });
 
   it("fills NaN with value", () => {
-    expect(fillna(NaN, { value: 99 })).toBe(99);
+    expect(fillna(Number.NaN, { value: 99 })).toBe(99);
   });
 
   it("leaves non-missing scalar unchanged", () => {
@@ -263,7 +261,7 @@ describe("fillna — scalar", () => {
 
 describe("fillna — array", () => {
   it("replaces null and NaN with value, keeps rest", () => {
-    expect(fillna([1, null, NaN, 3], { value: 0 })).toEqual([1, 0, 0, 3]);
+    expect(fillna([1, null, Number.NaN, 3], { value: 0 })).toEqual([1, 0, 0, 3]);
   });
 
   it("replaces undefined", () => {
@@ -283,7 +281,7 @@ describe("fillna — array", () => {
 
 describe("fillna — Series", () => {
   it("replaces missing values in a Series", () => {
-    const result = fillna(s([1, null, NaN, 4]), { value: 0 });
+    const result = fillna(s([1, null, Number.NaN, 4]), { value: 0 });
     expect(sv(result as Series<Scalar>)).toEqual([1, 0, 0, 4]);
   });
 
@@ -300,7 +298,7 @@ describe("fillna — DataFrame", () => {
     const df = new DataFrame(
       new Map([
         ["a", s([1, null]) as Series<Scalar>],
-        ["b", s([NaN, 5]) as Series<Scalar>],
+        ["b", s([Number.NaN, 5]) as Series<Scalar>],
       ]),
     );
     const result = fillna(df, { value: 0 }) as DataFrame;
@@ -313,11 +311,11 @@ describe("fillna — DataFrame", () => {
 
 describe("dropna — array", () => {
   it("removes null, undefined, and NaN", () => {
-    expect(dropna([1, null, NaN, 3, undefined, 5])).toEqual([1, 3, 5]);
+    expect(dropna([1, null, Number.NaN, 3, undefined, 5])).toEqual([1, 3, 5]);
   });
 
   it("returns empty array when all missing", () => {
-    expect(dropna([null, NaN, undefined])).toEqual([]);
+    expect(dropna([null, Number.NaN, undefined])).toEqual([]);
   });
 
   it("returns unchanged array when none missing", () => {
@@ -333,7 +331,7 @@ describe("dropna — array", () => {
 
 describe("dropna — Series", () => {
   it("drops missing values from a Series", () => {
-    const result = dropna(s([1, null, NaN, 4])) as Series<Scalar>;
+    const result = dropna(s([1, null, Number.NaN, 4])) as Series<Scalar>;
     expect(sv(result)).toEqual([1, 4]);
   });
 
@@ -343,7 +341,7 @@ describe("dropna — Series", () => {
   });
 
   it("returns empty Series when all missing", () => {
-    const result = dropna(s([null, NaN])) as Series<Scalar>;
+    const result = dropna(s([null, Number.NaN])) as Series<Scalar>;
     expect(sv(result)).toEqual([]);
   });
 });
@@ -458,7 +456,7 @@ describe("dropna — DataFrame axis=1", () => {
 
 describe("countna", () => {
   it("counts nulls, undefineds, NaNs in array", () => {
-    expect(countna([1, null, NaN, 3, undefined])).toBe(3);
+    expect(countna([1, null, Number.NaN, 3, undefined])).toBe(3);
   });
 
   it("returns 0 for complete array", () => {
@@ -466,7 +464,7 @@ describe("countna", () => {
   });
 
   it("counts missing values in Series", () => {
-    expect(countna(s([null, 1, NaN]))).toBe(2);
+    expect(countna(s([null, 1, Number.NaN]))).toBe(2);
   });
 
   it("returns 0 for empty array", () => {
@@ -476,7 +474,7 @@ describe("countna", () => {
 
 describe("countValid", () => {
   it("counts non-missing values in array", () => {
-    expect(countValid([1, null, NaN, 3, undefined])).toBe(2);
+    expect(countValid([1, null, Number.NaN, 3, undefined])).toBe(2);
   });
 
   it("returns full length for complete array", () => {
@@ -484,7 +482,7 @@ describe("countValid", () => {
   });
 
   it("counts valid values in Series", () => {
-    expect(countValid(s([null, 1, NaN, 4]))).toBe(2);
+    expect(countValid(s([null, 1, Number.NaN, 4]))).toBe(2);
   });
 });
 
@@ -519,7 +517,9 @@ describe("property: fillna removes all missing values (array)", () => {
     fc.assert(
       fc.property(scalarsArb, (arr) => {
         const filled = fillna(arr, { value: 0 });
-        return !filled.some((v) => v === null || v === undefined || (typeof v === "number" && Number.isNaN(v)));
+        return !filled.some(
+          (v) => v === null || v === undefined || (typeof v === "number" && Number.isNaN(v)),
+        );
       }),
     );
   });
diff --git a/tests/stats/numeric_extended.test.ts b/tests/stats/numeric_extended.test.ts
index 101ed90b..8697e7ac 100644
--- a/tests/stats/numeric_extended.test.ts
+++ b/tests/stats/numeric_extended.test.ts
@@ -96,7 +96,7 @@ describe("histogram", () => {
   it("2-bin example", () => {
     const { counts } = histogram([1, 2, 3, 4, 5], { bins: 2 });
     expect(counts.length).toBe(2);
-    expect(counts[0]! + counts[1]!).toBe(5);
+    expect((counts[0] ?? 0) + (counts[1] ?? 0)).toBe(5);
   });
 
   it("right-most value lands in last bin", () => {
@@ -110,7 +110,7 @@ describe("histogram", () => {
     });
     expect(binEdges).toEqual([1, 3, 5]);
     expect(counts.length).toBe(2);
-    expect(counts[0]! + counts[1]!).toBe(5);
+    expect((counts[0] ?? 0) + (counts[1] ?? 0)).toBe(5);
   });
 
   it("density normalisation: integral ≈ 1", () => {
@@ -137,7 +137,7 @@ describe("histogram", () => {
   it("degenerate range (all same value): still produces bins", () => {
     const { counts, binEdges } = histogram([5, 5, 5]);
     expect(binEdges[0]).toBe(4.5);
-    expect(binEdges[binEdges.length - 1]).toBe(5.5);
+    expect(binEdges.at(-1)).toBe(5.5);
     expect(counts.reduce((a, b) => a + b, 0)).toBe(3);
   });
 
@@ -188,7 +188,7 @@ describe("linspace", () => {
 
   it("last element is exactly stop (no floating-point drift)", () => {
     const r = linspace(0, 10, 100);
-    expect(r[r.length - 1]).toBe(10);
+    expect(r.at(-1)).toBe(10);
   });
 });
 
@@ -309,10 +309,10 @@ describe("zscore", () => {
     const s = ns([1, 2, 3, 4, 5]);
     const z0 = vals(zscore(s, { ddof: 0 })).filter((v): v is number => typeof v === "number");
     const z1 = vals(zscore(s, { ddof: 1 })).filter((v): v is number => typeof v === "number");
-    // ddof=0 produces smaller values (divided by larger std denominator)
+    // ddof=0 divides by n (not n-1), producing smaller std → larger z-scores
     const range0 = Math.max(...z0) - Math.min(...z0);
     const range1 = Math.max(...z1) - Math.min(...z1);
-    expect(range0).toBeLessThan(range1);
+    expect(range0).toBeGreaterThan(range1);
   });
 
   it("preserves index labels", () => {
@@ -463,8 +463,9 @@ describe("property: linspace endpoints", () => {
         (start, stop, num) => {
           const r = linspace(start, stop, num);
           expect(r.length).toBe(num);
-          expect(r[0]).toBe(start);
-          expect(r[r.length - 1]).toBe(stop);
+          // Use toEqual to handle -0 === 0 correctly
+          expect(r[0]).toEqual(start);
+          expect(r.at(-1)).toEqual(stop);
         },
       ),
     );
@@ -498,8 +499,12 @@ describe("property: zscore mean is approximately 0", () => {
         }),
         (data) => {
           const s = new Series({ data: data as Scalar[] });
-          const z = vals(zscore(s)).filter((v): v is number => typeof v === "number" && !Number.isNaN(v));
-          if (z.length < 2) return;
+          const z = vals(zscore(s)).filter(
+            (v): v is number => typeof v === "number" && !Number.isNaN(v),
+          );
+          if (z.length < 2) {
+            return;
+          }
           const mean = z.reduce((a, b) => a + b, 0) / z.length;
           expect(Math.abs(mean)).toBeLessThan(1e-8);
         },
diff --git a/tests/stats/string_ops.test.ts b/tests/stats/string_ops.test.ts
index f9e9a0b4..0f5b84cc 100644
--- a/tests/stats/string_ops.test.ts
+++ b/tests/stats/string_ops.test.ts
@@ -84,7 +84,7 @@ describe("strGetDummies", () => {
   it("basic | separator", () => {
     const df = strGetDummies(s(["a|b", "b|c", "a"]));
     expect(df.shape[0]).toBe(3);
-    expect(df.columns.values.sort()).toEqual(["a", "b", "c"]);
+    expect([...df.columns.values].sort()).toEqual(["a", "b", "c"]);
     expect(df.col("a").values[0]).toBe(1);
     expect(df.col("a").values[1]).toBe(0);
     expect(df.col("a").values[2]).toBe(1);
@@ -98,12 +98,12 @@ describe("strGetDummies", () => {
 
   it("custom separator", () => {
     const df = strGetDummies(s(["a,b", "b,c"]), { sep: "," });
-    expect(df.columns.values.sort()).toEqual(["a", "b", "c"]);
+    expect([...df.columns.values].sort()).toEqual(["a", "b", "c"]);
   });
 
   it("prefix option", () => {
     const df = strGetDummies(s(["x|y"]), { prefix: "tag", prefixSep: "-" });
-    expect(df.columns.values.sort()).toEqual(["tag-x", "tag-y"]);
+    expect([...df.columns.values].sort()).toEqual(["tag-x", "tag-y"]);
   });
 
   it("empty string element maps to no tokens", () => {
@@ -136,7 +136,7 @@ describe("strGetDummies", () => {
   it("array input (not Series)", () => {
     const df = strGetDummies(["a|b", "c"]);
     expect(df.shape[0]).toBe(2);
-    expect(df.columns.values.sort()).toEqual(["a", "b", "c"]);
+    expect([...df.columns.values].sort()).toEqual(["a", "b", "c"]);
   });
 });
 
@@ -256,7 +256,10 @@ describe("strRemoveSuffix", () => {
 
 describe("strTranslate", () => {
   it("replaces characters according to table", () => {
-    const table = new Map<string, string | null>([["a", "A"], ["e", "E"]]);
+    const table = new Map<string, string | null>([
+      ["a", "A"],
+      ["e", "E"],
+    ]);
     expect(strTranslate("hello", table)).toBe("hEllo");
     expect(strTranslate("abc", table)).toBe("Abc");
   });
@@ -297,7 +300,11 @@ describe("strTranslate", () => {
 
   it("delete all vowels", () => {
     const table = new Map<string, string | null>([
-      ["a", null], ["e", null], ["i", null], ["o", null], ["u", null],
+      ["a", null],
+      ["e", null],
+      ["i", null],
+      ["o", null],
+      ["u", null],
     ]);
     expect(strTranslate("hello world", table)).toBe("hll wrld");
   });
@@ -412,7 +419,7 @@ describe("strRemovePrefix — properties", () => {
     fc.assert(
       fc.property(fc.asciiString(), fc.asciiString({ minLength: 1 }), (str, prefix) => {
         const result = strRemovePrefix(str, prefix);
-        return !result.startsWith(prefix) || !str.startsWith(prefix);
+        return !(result.startsWith(prefix) && str.startsWith(prefix));
       }),
     );
   });
diff --git a/tests/stats/string_ops_extended.test.ts b/tests/stats/string_ops_extended.test.ts
index 6a3b4fe8..4b0b1e14 100644
--- a/tests/stats/string_ops_extended.test.ts
+++ b/tests/stats/string_ops_extended.test.ts
@@ -5,7 +5,7 @@
  */
 import { describe, expect, it } from "bun:test";
 import fc from "fast-check";
-import { DataFrame, Series } from "../../src/index.ts";
+import { type DataFrame, Series } from "../../src/index.ts";
 import type { Scalar } from "../../src/index.ts";
 import {
   strDedent,
@@ -368,7 +368,7 @@ describe("strSplitExpand — property tests", () => {
           const df = strSplitExpand(arr as Scalar[], "|");
           const cols = df.columns.values as string[];
           // rejoin each row
-          const rejoined = arr.map((s, ri) => {
+          const rejoined = arr.map((_s, ri) => {
             return cols.map((c) => df.col(c).iat(ri) ?? "").join("|");
           });
           // compare (escaped) — the round-trip should work if the original had no "|" in it
@@ -387,9 +387,8 @@ describe("strPartition / strRPartition — property tests", () => {
         const [before, mid, after] = strPartition(str, sep);
         if (str.includes(sep)) {
           return before + mid + after === str;
-        } else {
-          return before === str && mid === "" && after === "";
         }
+        return before === str && mid === "" && after === "";
       }),
     );
   });
@@ -400,9 +399,8 @@ describe("strPartition / strRPartition — property tests", () => {
         const [before, mid, after] = strRPartition(str, sep);
         if (str.includes(sep)) {
           return before + mid + after === str;
-        } else {
-          return before === "" && mid === "" && after === str;
         }
+        return before === "" && mid === "" && after === str;
       }),
     );
   });
@@ -412,10 +410,13 @@ describe("strDedent — property tests", () => {
   it("dedent-then-indent is idempotent on uniform indentation", () => {
     fc.assert(
       fc.property(
-        fc.array(fc.string({ minLength: 1 }).filter((s) => !s.includes("\n")), {
-          minLength: 1,
-          maxLength: 5,
-        }),
+        fc.array(
+          fc.string({ minLength: 1 }).filter((s) => !s.includes("\n")),
+          {
+            minLength: 1,
+            maxLength: 5,
+          },
+        ),
         fc.integer({ min: 0, max: 8 }),
         (lines, spaces) => {
           const prefix = " ".repeat(spaces);
@@ -430,8 +431,6 @@ describe("strDedent — property tests", () => {
 
 describe("strMultiReplace — property tests", () => {
   it("empty replacements is identity", () => {
-    fc.assert(
-      fc.property(fc.string(), (str) => strMultiReplace(str, []) === str),
-    );
+    fc.assert(fc.property(fc.string(), (str) => strMultiReplace(str, []) === str));
   });
 });
diff --git a/tests/stats/where_mask.test.ts b/tests/stats/where_mask.test.ts
index 670019f1..401d0210 100644
--- a/tests/stats/where_mask.test.ts
+++ b/tests/stats/where_mask.test.ts
@@ -91,10 +91,7 @@ describe("seriesWhere — Series<boolean> cond (label-aligned)", () => {
 
 describe("seriesWhere — callable cond", () => {
   it("callable returning boolean array", () => {
-    const result = seriesWhere(
-      s([1, 2, 3, 4, 5]),
-      (x) => x.values.map((v) => (v as number) > 3),
-    );
+    const result = seriesWhere(s([1, 2, 3, 4, 5]), (x) => x.values.map((v) => (v as number) > 3));
     expect(sv(result)).toEqual([null, null, null, 4, 5]);
   });
 
@@ -108,11 +105,9 @@ describe("seriesWhere — callable cond", () => {
   });
 
   it("callable with other value", () => {
-    const result = seriesWhere(
-      s([5, 10, 15]),
-      (x) => x.values.map((v) => (v as number) > 7),
-      { other: -1 },
-    );
+    const result = seriesWhere(s([5, 10, 15]), (x) => x.values.map((v) => (v as number) > 7), {
+      other: -1,
+    });
     expect(sv(result)).toEqual([-1, 10, 15]);
   });
 });
@@ -148,11 +143,9 @@ describe("seriesMask — boolean array", () => {
 
 describe("seriesMask — callable cond", () => {
   it("masks values satisfying condition", () => {
-    const result = seriesMask(
-      s([1, 2, 3, 4, 5]),
-      (x) => x.values.map((v) => (v as number) > 3),
-      { other: 0 },
-    );
+    const result = seriesMask(s([1, 2, 3, 4, 5]), (x) => x.values.map((v) => (v as number) > 3), {
+      other: 0,
+    });
     expect(sv(result)).toEqual([1, 2, 3, 0, 0]);
   });
 });
diff --git a/tests/stats/window_extended.test.ts b/tests/stats/window_extended.test.ts
index e69ab2a5..cbda0b82 100644
--- a/tests/stats/window_extended.test.ts
+++ b/tests/stats/window_extended.test.ts
@@ -20,12 +20,16 @@ function s(data: readonly (number | null)[]): Series<Scalar> {
 }
 
 function vals(series: ReturnType<typeof rollingSem>): (number | null)[] {
-  return [...series.toArray()] as (number | null)[];
+  return [...series.values] as (number | null)[];
 }
 
 function close(a: Scalar, b: number, tol = 1e-9): boolean {
-  if (a === null || a === undefined) return false;
-  if (typeof a !== "number") return false;
+  if (a === null || a === undefined) {
+    return false;
+  }
+  if (typeof a !== "number") {
+    return false;
+  }
   return Math.abs(a - b) < tol;
 }
 
@@ -129,7 +133,8 @@ describe("rollingSkew", () => {
   });
 
   it("left-skewed data → negative skew", () => {
-    const out = vals(rollingSkew(s([10, 2, 1]), 3));
+    // [1, 9, 10] has a long left tail (low outlier) → negative skewness
+    const out = vals(rollingSkew(s([1, 9, 10]), 3));
     const v = out[2];
     expect(typeof v).toBe("number");
     expect((v as number) < 0).toBe(true);
@@ -217,7 +222,8 @@ describe("rollingQuantile", () => {
     expect(close(out[2] as number, 1)).toBe(true);
     expect(close(out[3] as number, 1)).toBe(true);
     expect(close(out[4] as number, 1)).toBe(true);
-    expect(close(out[5] as number, 5)).toBe(true);
+    // window [1,5,9] → min is 1
+    expect(close(out[5] as number, 1)).toBe(true);
   });
 
   it("q=1 is rolling maximum", () => {
@@ -234,31 +240,23 @@ describe("rollingQuantile", () => {
 
   it("interpolation=lower", () => {
     // [1,3] q=0.5 lower → 1
-    const out = vals(
-      rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "lower" }),
-    );
+    const out = vals(rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "lower" }));
     expect(close(out[1] as number, 1)).toBe(true);
   });
 
   it("interpolation=higher", () => {
-    const out = vals(
-      rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "higher" }),
-    );
+    const out = vals(rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "higher" }));
     expect(close(out[1] as number, 3)).toBe(true);
   });
 
   it("interpolation=midpoint", () => {
-    const out = vals(
-      rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "midpoint" }),
-    );
+    const out = vals(rollingQuantile(s([1, 3]), 0.5, 2, { interpolation: "midpoint" }));
     expect(close(out[1] as number, 2)).toBe(true);
   });
 
   it("interpolation=nearest", () => {
     // q=0.25 with [1,2,3,4]: virtual=0.75 → lo=0(1), hi=1(2), frac=0.75>0.5 → 2
-    const out = vals(
-      rollingQuantile(s([1, 2, 3, 4]), 0.25, 4, { interpolation: "nearest" }),
-    );
+    const out = vals(rollingQuantile(s([1, 2, 3, 4]), 0.25, 4, { interpolation: "nearest" }));
     expect(close(out[3] as number, 2)).toBe(true);
   });
 
@@ -269,9 +267,7 @@ describe("rollingQuantile", () => {
 
   it("null values skipped in window", () => {
     // [1, null, 3]: 2 valid [1,3]; minPeriods=2 → quantile(0.5)=2
-    const out = vals(
-      rollingQuantile(s([1, null, 3]), 0.5, 3, { minPeriods: 2 }),
-    );
+    const out = vals(rollingQuantile(s([1, null, 3]), 0.5, 3, { minPeriods: 2 }));
     expect(close(out[2] as number, 2)).toBe(true);
   });
 
@@ -286,9 +282,7 @@ describe("rollingQuantile", () => {
   });
 
   it("minPeriods=1 gives results for single-element windows", () => {
-    const out = vals(
-      rollingQuantile(s([5, 3, 8]), 0.5, 3, { minPeriods: 1 }),
-    );
+    const out = vals(rollingQuantile(s([5, 3, 8]), 0.5, 3, { minPeriods: 1 }));
     // index 0: window=[5] → quantile=5
     expect(close(out[0] as number, 5)).toBe(true);
     // index 2: window=[5,3,8] → sorted=[3,5,8] → median=5
@@ -311,8 +305,12 @@ describe("window_extended — property tests", () => {
           const result = vals(rollingSem(s(data), window));
           for (const v of result) {
             if (v !== null && v !== undefined) {
-              if (typeof v !== "number") return false;
-              if (v < -1e-12) return false;
+              if (typeof v !== "number") {
+                return false;
+              }
+              if (v < -1e-12) {
+                return false;
+              }
             }
           }
           return true;
@@ -337,9 +335,15 @@ describe("window_extended — property tests", () => {
             const l = lo[i];
             const m = med[i];
             const h = hi[i];
-            if (l === null || m === null || h === null) continue;
-            if ((l as number) > (m as number) + 1e-9) return false;
-            if ((m as number) > (h as number) + 1e-9) return false;
+            if (l === null || m === null || h === null) {
+              continue;
+            }
+            if ((l as number) > (m as number) + 1e-9) {
+              return false;
+            }
+            if ((m as number) > (h as number) + 1e-9) {
+              return false;
+            }
           }
           return true;
         },
diff --git a/tests/window/rolling_apply.test.ts b/tests/window/rolling_apply.test.ts
index 8fc7b0fd..912329cc 100644
--- a/tests/window/rolling_apply.test.ts
+++ b/tests/window/rolling_apply.test.ts
@@ -94,7 +94,8 @@ describe("rollingApply", () => {
 
   test("custom min function", () => {
     const out = rollingApply(s(3, 1, 4, 1, 5, 9), 3, numMin);
-    expect(out.toArray()).toEqual([null, null, 1, 1, 1, 5]);
+    // window [1,5,9] → min is 1, not 5
+    expect(out.toArray()).toEqual([null, null, 1, 1, 1, 1]);
   });
 
   test("raw=true passes valid nums only (same as default)", () => {
@@ -120,7 +121,7 @@ describe("rollingApply", () => {
 
   test("pairwise diff function", () => {
     // last - first in window
-    const diff = (nums: readonly number[]) => nums[nums.length - 1]! - nums[0]!;
+    const diff = (nums: readonly number[]) => (nums.at(-1) ?? 0) - (nums[0] ?? 0);
     const out = rollingApply(s(1, 3, 6, 10, 15), 3, diff);
     expect(out.toArray()).toEqual([null, null, 5, 7, 9]);
   });
@@ -143,9 +144,10 @@ describe("rollingApply", () => {
   });
 
   test("count function behaves correctly", () => {
-    const count = (nums: readonly number[]) => nums.length;
+    const count = (nums: readonly number[]): number => nums.length;
     const out = rollingApply(s(1, null, 3, null, 5), 3, count, { minPeriods: 1 });
-    expect(out.toArray()).toEqual([1, 1, 2, 2, 2]);
+    // window at i=3: [null,3,null] → valid=[3] → count=1
+    expect(out.toArray()).toEqual([1, 1, 2, 1, 2]);
   });
 
   test("range function over window", () => {
@@ -242,7 +244,7 @@ describe("dataFrameRollingApply", () => {
   });
 
   test("custom function applied independently per column", () => {
-    const diff = (nums: readonly number[]) => nums[nums.length - 1]! - nums[0]!;
+    const diff = (nums: readonly number[]) => (nums.at(-1) ?? 0) - (nums[0] ?? 0);
     const df = DataFrame.fromColumns({ a: [1, 3, 6], b: [10, 15, 21] });
     const out = dataFrameRollingApply(df, 2, diff);
     expect(out.col("a").toArray()).toEqual([null, 2, 3]);
@@ -298,7 +300,10 @@ describe("rollingApply property tests", () => {
   test("output length equals input length", () => {
     fc.assert(
       fc.property(
-        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), { minLength: 0, maxLength: 20 }),
+        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), {
+          minLength: 0,
+          maxLength: 20,
+        }),
         fc.integer({ min: 1, max: 5 }),
         (data, window) => {
           const series = new Series({ data });
@@ -312,7 +317,10 @@ describe("rollingApply property tests", () => {
   test("leading nulls count equals min(window-1, n) for standard mode", () => {
     fc.assert(
       fc.property(
-        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), { minLength: 1, maxLength: 20 }),
+        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), {
+          minLength: 1,
+          maxLength: 20,
+        }),
         fc.integer({ min: 1, max: 8 }),
         (data, window) => {
           const series = new Series({ data });
@@ -321,8 +329,11 @@ describe("rollingApply property tests", () => {
           const expectedNulls = Math.min(window - 1, data.length);
           let leadingNulls = 0;
           for (const v of vals) {
-            if (v === null) leadingNulls++;
-            else break;
+            if (v === null) {
+              leadingNulls++;
+            } else {
+              break;
+            }
           }
           return leadingNulls === expectedNulls;
         },
@@ -333,7 +344,10 @@ describe("rollingApply property tests", () => {
   test("rollingAgg columns match individual rollingApply", () => {
     fc.assert(
       fc.property(
-        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), { minLength: 0, maxLength: 15 }),
+        fc.array(fc.float({ noNaN: true, noDefaultInfinity: true }), {
+          minLength: 0,
+          maxLength: 15,
+        }),
         fc.integer({ min: 1, max: 5 }),
         (data, window) => {
           const series = new Series({ data });
@@ -341,11 +355,9 @@ describe("rollingApply property tests", () => {
           const appliedSum = rollingApply(series, window, numSum);
           const appliedMax = rollingApply(series, window, numMax);
           const sumOk =
-            JSON.stringify(agg.col("sum").toArray()) ===
-            JSON.stringify(appliedSum.toArray());
+            JSON.stringify(agg.col("sum").toArray()) === JSON.stringify(appliedSum.toArray());
           const maxOk =
-            JSON.stringify(agg.col("max").toArray()) ===
-            JSON.stringify(appliedMax.toArray());
+            JSON.stringify(agg.col("max").toArray()) === JSON.stringify(appliedMax.toArray());
           return sumOk && maxOk;
         },
       ),