diff --git a/benchmarks/results-wasm-core.json b/benchmarks/results-wasm-core.json
index 11c4ca4e..23bad732 100644
--- a/benchmarks/results-wasm-core.json
+++ b/benchmarks/results-wasm-core.json
@@ -3,160 +3,160 @@
     {
       "function": "searchsorted_f64",
       "tsb": {
-        "mean_ms": 0.0008374999999999986,
+        "mean_ms": 0.0016710259999999978,
         "iterations": 1000,
-        "total_ms": 0.8374999999999986
+        "total_ms": 1.6710259999999977
       },
       "tsb_wasm": {
-        "mean_ms": 0.0021370410000000036,
+        "mean_ms": 0.028031712999999996,
         "iterations": 1000,
-        "total_ms": 2.1370410000000035
+        "total_ms": 28.031712999999996
       },
-      "wasm_speedup": 0.39189702022562845
+      "wasm_speedup": 0.05961198304220645
     },
     {
       "function": "searchsorted_many_f64",
       "tsb": {
-        "mean_ms": 0.0034607080000000037,
+        "mean_ms": 0.003219333999999989,
         "iterations": 1000,
-        "total_ms": 3.460708000000004
+        "total_ms": 3.2193339999999893
       },
       "tsb_wasm": {
-        "mean_ms": 0.005887209000000006,
+        "mean_ms": 0.034363152,
         "iterations": 1000,
-        "total_ms": 5.887209000000006
+        "total_ms": 34.363152
       },
-      "wasm_speedup": 0.5878350845026905
+      "wasm_speedup": 0.09368564327277047
     },
     {
       "function": "argsort_f64",
       "tsb": {
-        "mean_ms": 0.1133425,
+        "mean_ms": 0.21699383,
         "iterations": 1000,
-        "total_ms": 113.3425
+        "total_ms": 216.99383
       },
       "tsb_wasm": {
-        "mean_ms": 0.01931533300000001,
+        "mean_ms": 0.057585872999999996,
         "iterations": 1000,
-        "total_ms": 19.31533300000001
+        "total_ms": 57.58587299999999
       },
-      "wasm_speedup": 5.8680065210369365
+      "wasm_speedup": 3.768178178005568
     },
     {
       "function": "searchsorted_str",
       "tsb": {
-        "mean_ms": 0.00027391700000001153,
+        "mean_ms": 0.0009189930000000004,
         "iterations": 1000,
-        "total_ms": 0.2739170000000115
+        "total_ms": 0.9189930000000004
       },
       "tsb_wasm": {
-        "mean_ms": 0.002622792000000004,
+        "mean_ms": 0.007566859999999963,
         "iterations": 1000,
-        "total_ms": 2.622792000000004
+        "total_ms": 7.566859999999963
       },
-      "wasm_speedup": 0.10443717992124847,
+      "wasm_speedup": 0.12144971626275694,
       "notes": "String arrays are copied for each WASM call; raw kernel speedup is partially offset by copy overhead."
     },
     {
       "function": "argsort_str",
       "tsb": {
-        "mean_ms": 0.0004121250000000032,
+        "mean_ms": 0.002078239999999994,
         "iterations": 1000,
-        "total_ms": 0.4121250000000032
+        "total_ms": 2.078239999999994
       },
       "tsb_wasm": {
-        "mean_ms": 0.0014684579999999982,
+        "mean_ms": 0.004294708000000014,
         "iterations": 1000,
-        "total_ms": 1.4684579999999983
+        "total_ms": 4.294708000000014
       },
-      "wasm_speedup": 0.28065154059564773,
+      "wasm_speedup": 0.4839071713373731,
       "notes": "Same array-copy caveat as searchsorted_str."
     },
     {
       "function": "nat_compare",
       "tsb": {
-        "mean_ms": 0.0004783749999999998,
+        "mean_ms": 0.0010837179999999762,
         "iterations": 1000,
-        "total_ms": 0.4783749999999998
+        "total_ms": 1.0837179999999762
       },
       "tsb_wasm": {
-        "mean_ms": 0.001035334000000006,
+        "mean_ms": 0.004259321,
         "iterations": 1000,
-        "total_ms": 1.035334000000006
+        "total_ms": 4.259321
       },
-      "wasm_speedup": 0.4620489619774846
+      "wasm_speedup": 0.25443445093712735
     },
     {
       "function": "nat_sorted",
       "tsb": {
-        "mean_ms": 0.16902662499999996,
+        "mean_ms": 0.226383055,
         "iterations": 1000,
-        "total_ms": 169.02662499999997
+        "total_ms": 226.383055
       },
       "tsb_wasm": {
-        "mean_ms": 0.257211584,
+        "mean_ms": 0.5151697199999998,
         "iterations": 1000,
-        "total_ms": 257.211584
+        "total_ms": 515.1697199999999
       },
-      "wasm_speedup": 0.6571501266443737
+      "wasm_speedup": 0.4394339306277552
     },
     {
       "function": "nat_argsort",
       "tsb": {
-        "mean_ms": 0.03192166599999996,
+        "mean_ms": 0.05495564300000001,
         "iterations": 1000,
-        "total_ms": 31.92166599999996
+        "total_ms": 54.95564300000001
       },
       "tsb_wasm": {
-        "mean_ms": 0.035225500000000014,
+        "mean_ms": 0.06736009400000012,
         "iterations": 1000,
-        "total_ms": 35.22550000000001
+        "total_ms": 67.36009400000012
       },
-      "wasm_speedup": 0.9062090247122099
+      "wasm_speedup": 0.815848668500966
     }
   ],
   "coverage": {
     "unclassified": 0,
     "eligible_missing": 0,
-    "total_core_entries": 121,
+    "total_core_entries": 143,
     "rust_wasm": 6,
-    "ts_only_ineligible": 115
+    "ts_only_ineligible": 137
   },
-  "timestamp": "2026-06-27T02:33:54.386Z",
+  "timestamp": "2026-07-02T09:46:21.112Z",
   "slower_than_typescript": [
     {
       "function": "searchsorted_f64",
-      "wasm_speedup": 0.39189702022562845,
+      "wasm_speedup": 0.05961198304220645,
       "explanation": "WASM/JS boundary overhead exceeds kernel speedup at this array size."
     },
     {
       "function": "searchsorted_many_f64",
-      "wasm_speedup": 0.5878350845026905,
+      "wasm_speedup": 0.09368564327277047,
       "explanation": "WASM/JS boundary overhead exceeds kernel speedup at this array size."
     },
     {
       "function": "searchsorted_str",
-      "wasm_speedup": 0.10443717992124847,
+      "wasm_speedup": 0.12144971626275694,
       "explanation": "String arrays are copied for each WASM call; raw kernel speedup is partially offset by copy overhead."
     },
     {
       "function": "argsort_str",
-      "wasm_speedup": 0.28065154059564773,
+      "wasm_speedup": 0.4839071713373731,
       "explanation": "Same array-copy caveat as searchsorted_str."
     },
     {
       "function": "nat_compare",
-      "wasm_speedup": 0.4620489619774846,
+      "wasm_speedup": 0.25443445093712735,
       "explanation": "WASM/JS boundary overhead exceeds kernel speedup at this array size."
     },
     {
       "function": "nat_sorted",
-      "wasm_speedup": 0.6571501266443737,
+      "wasm_speedup": 0.4394339306277552,
       "explanation": "WASM/JS boundary overhead exceeds kernel speedup at this array size."
     },
     {
       "function": "nat_argsort",
-      "wasm_speedup": 0.9062090247122099,
+      "wasm_speedup": 0.815848668500966,
       "explanation": "WASM/JS boundary overhead exceeds kernel speedup at this array size."
     }
   ]
diff --git a/benchmarks/wasm-core/run.ts b/benchmarks/wasm-core/run.ts
index 221292cd..6b2b65f6 100644
--- a/benchmarks/wasm-core/run.ts
+++ b/benchmarks/wasm-core/run.ts
@@ -227,6 +227,49 @@ const benchmarks: BenchmarkEntry[] = [];
   });
 }
 
+// ─── sum_f64 ──────────────────────────────────────────────────────────────────
+
+{
+  const sumF64Wasm = getWasmFn("sum_f64");
+  const DATA_F64 = Float64Array.from({ length: 10_000 }, (_, i) => i * 0.5);
+  const DATA_ARR = Array.from(DATA_F64);
+  const tsResult = bench(() => DATA_ARR.reduce((acc, v) => acc + v, 0), ITERS);
+  const wasmResult = bench(() => sumF64Wasm(DATA_F64), ITERS);
+  benchmarks.push({
+    function: "sum_f64",
+    tsb: tsResult,
+    tsb_wasm: wasmResult,
+    wasm_speedup: tsResult.mean_ms / wasmResult.mean_ms,
+    notes: "Scalar sum over 10 000-element f64 array; WASM avoids JS→TS dispatch overhead.",
+  });
+}
+
+// ─── rolling_mean_f64 ────────────────────────────────────────────────────────
+
+{
+  const rollingMeanWasm = getWasmFn("rolling_mean_f64");
+  const ROLL_DATA = Float64Array.from({ length: 1_000 }, (_, i) => i * 1.0);
+  const ROLL_ARR = Array.from(ROLL_DATA);
+  const window = 10;
+  const minPeriods = 10;
+  const tsResult = bench(() => {
+    return ROLL_ARR.map((_, i) => {
+      const start = Math.max(0, i + 1 - window);
+      const slice = ROLL_ARR.slice(start, i + 1).filter((v) => !Number.isNaN(v));
+      if (slice.length < minPeriods) return null;
+      return slice.reduce((a, b) => a + b, 0) / slice.length;
+    });
+  }, ITERS);
+  const wasmResult = bench(() => rollingMeanWasm(ROLL_DATA, window, minPeriods), ITERS);
+  benchmarks.push({
+    function: "rolling_mean_f64",
+    tsb: tsResult,
+    tsb_wasm: wasmResult,
+    wasm_speedup: tsResult.mean_ms / wasmResult.mean_ms,
+    notes: "Rolling window mean over 1 000 elements with window=10.",
+  });
+}
+
 // ─── coverage summary ─────────────────────────────────────────────────────────
 
 const coverageManifest = JSON.parse(
diff --git a/rust/pkg/tsb_wasm.d.ts b/rust/pkg/tsb_wasm.d.ts
index 9bc64dec..a195415b 100644
--- a/rust/pkg/tsb_wasm.d.ts
+++ b/rust/pkg/tsb_wasm.d.ts
@@ -13,6 +13,66 @@ export function argsort_f64(arr: Float64Array): Uint32Array;
  */
 export function argsort_str(arr: string[]): Uint32Array;
 
+/**
+ * Expanding maximum.
+ */
+export function expanding_max_f64(data: Float64Array, min_periods: number): Float64Array;
+
+/**
+ * Expanding mean.
+ */
+export function expanding_mean_f64(data: Float64Array, min_periods: number): Float64Array;
+
+/**
+ * Expanding median.
+ */
+export function expanding_median_f64(data: Float64Array, min_periods: number): Float64Array;
+
+/**
+ * Expanding minimum.
+ */
+export function expanding_min_f64(data: Float64Array, min_periods: number): Float64Array;
+
+/**
+ * Expanding standard deviation (delta degrees-of-freedom `ddof`).
+ */
+export function expanding_std_f64(data: Float64Array, min_periods: number, ddof: number): Float64Array;
+
+/**
+ * Expanding sum.
+ */
+export function expanding_sum_f64(data: Float64Array, min_periods: number): Float64Array;
+
+/**
+ * Expanding variance (delta degrees-of-freedom `ddof`).
+ */
+export function expanding_var_f64(data: Float64Array, min_periods: number, ddof: number): Float64Array;
+
+/**
+ * Maximum of non-NaN values. Returns `NaN` for empty / all-NaN input.
+ */
+export function max_f64(data: Float64Array): number;
+
+/**
+ * Arithmetic mean of non-NaN values. Returns `NaN` for empty / all-NaN input,
+ * matching `Series.mean()`.
+ */
+export function mean_f64(data: Float64Array): number;
+
+/**
+ * Median of non-NaN values (middle value of sorted data; average of two
+ * middle values for even-length arrays). Returns `NaN` for empty / all-NaN
+ * input, matching `Series.median()`.
+ */
+export function median_f64(data: Float64Array): number;
+
+/**
+ * Minimum of non-NaN values. Returns `NaN` for empty / all-NaN input,
+ * matching `Series.min()` returning `undefined` (coerced to NaN in numeric
+ * contexts).
+ */
+export function min_f64(data: Float64Array): number;
+
 /**
  * Return the indices that would sort `arr` in natural order.
  */
@@ -38,6 +98,42 @@ export function nat_compare(a: string, b: string, ignore_case: boolean, reverse:
  */
 export function nat_sorted(arr: string[], ignore_case: boolean, reverse: boolean): string[];
 
+/**
+ * Rolling maximum.
+ */
+export function rolling_max_f64(data: Float64Array, window: number, min_periods: number): Float64Array;
+
+/**
+ * Rolling arithmetic mean.
+ */
+export function rolling_mean_f64(data: Float64Array, window: number, min_periods: number): Float64Array;
+
+/**
+ * Rolling median.
+ */
+export function rolling_median_f64(data: Float64Array, window: number, min_periods: number): Float64Array;
+
+/**
+ * Rolling minimum.
+ */
+export function rolling_min_f64(data: Float64Array, window: number, min_periods: number): Float64Array;
+
+/**
+ * Rolling standard deviation (delta degrees-of-freedom `ddof`).
+ */
+export function rolling_std_f64(data: Float64Array, window: number, min_periods: number, ddof: number): Float64Array;
+
+/**
+ * Rolling sum. Positions with fewer than `min_periods` non-NaN values → NaN.
+ */
+export function rolling_sum_f64(data: Float64Array, window: number, min_periods: number): Float64Array;
+
+/**
+ * Rolling variance (delta degrees-of-freedom `ddof`).
+ * Positions with fewer than `ddof + 1` valid values → NaN.
+ */
+export function rolling_var_f64(data: Float64Array, window: number, min_periods: number, ddof: number): Float64Array;
+
 /**
  * Binary-search a sorted f64 slice for `value`.
  *
@@ -65,3 +161,22 @@ export function searchsorted_many_str(arr: string[], values: string[], side_righ
  * Binary-search a sorted array of strings for `value`.
  */
 export function searchsorted_str(arr: string[], value: string, side_right: boolean): number;
+
+/**
+ * Sample standard deviation with delta degrees-of-freedom `ddof`.
+ * Returns `NaN` when fewer than `ddof + 1` valid values exist.
+ */
+export function std_f64(data: Float64Array, ddof: number): number;
+
+/**
+ * Sum of non-NaN values. Returns `0.0` when there are no valid values,
+ * matching `Series.sum()` on an all-null / empty series.
+ */
+export function sum_f64(data: Float64Array): number;
+
+/**
+ * Sample variance of non-NaN values with delta degrees-of-freedom `ddof`.
+ * Returns `NaN` when fewer than `ddof + 1` valid values exist, matching
+ * `Series.var(ddof)`.
+ */
+export function var_f64(data: Float64Array, ddof: number): number;
diff --git a/rust/pkg/tsb_wasm.js b/rust/pkg/tsb_wasm.js
index 2f9cae8a..0924a6f3 100644
--- a/rust/pkg/tsb_wasm.js
+++ b/rust/pkg/tsb_wasm.js
@@ -32,6 +32,177 @@ function argsort_str(arr) {
 }
 exports.argsort_str = argsort_str;
 
+/**
+ * Expanding maximum.
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function expanding_max_f64(data, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_max_f64(ptr0, len0, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_max_f64 = expanding_max_f64;
+
+/**
+ * Expanding mean.
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function expanding_mean_f64(data, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_mean_f64(ptr0, len0, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_mean_f64 = expanding_mean_f64;
+
+/**
+ * Expanding median.
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function expanding_median_f64(data, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_median_f64(ptr0, len0, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_median_f64 = expanding_median_f64;
+
+/**
+ * Expanding minimum.
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function expanding_min_f64(data, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_min_f64(ptr0, len0, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_min_f64 = expanding_min_f64;
+
+/**
+ * Expanding standard deviation (delta degrees-of-freedom `ddof`).
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @param {number} ddof
+ * @returns {Float64Array}
+ */
+function expanding_std_f64(data, min_periods, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_std_f64(ptr0, len0, min_periods, ddof);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_std_f64 = expanding_std_f64;
+
+/**
+ * Expanding sum.
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function expanding_sum_f64(data, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_sum_f64(ptr0, len0, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_sum_f64 = expanding_sum_f64;
+
+/**
+ * Expanding variance (delta degrees-of-freedom `ddof`).
+ * @param {Float64Array} data
+ * @param {number} min_periods
+ * @param {number} ddof
+ * @returns {Float64Array}
+ */
+function expanding_var_f64(data, min_periods, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.expanding_var_f64(ptr0, len0, min_periods, ddof);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.expanding_var_f64 = expanding_var_f64;
+
+/**
+ * Maximum of non-NaN values. Returns `NaN` for empty / all-NaN input.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function max_f64(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.max_f64(ptr0, len0);
+    return ret;
+}
+exports.max_f64 = max_f64;
+
+/**
+ * Arithmetic mean of non-NaN values. Returns `NaN` for empty / all-NaN input,
+ * matching `Series.mean()`.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function mean_f64(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mean_f64(ptr0, len0);
+    return ret;
+}
+exports.mean_f64 = mean_f64;
+
+/**
+ * Median of non-NaN values (middle value of sorted data; average of two
+ * middle values for even-length arrays). Returns `NaN` for empty / all-NaN
+ * input, matching `Series.median()`.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function median_f64(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.median_f64(ptr0, len0);
+    return ret;
+}
+exports.median_f64 = median_f64;
+
+/**
+ * Minimum of non-NaN values. Returns `NaN` for empty / all-NaN input,
+ * matching `Series.min()` returning `undefined` (coerced to NaN in numeric
+ * contexts).
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function min_f64(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.min_f64(ptr0, len0);
+    return ret;
+}
+exports.min_f64 = min_f64;
+
 /**
  * Return the indices that would sort `arr` in natural order.
  * @param {string[]} arr
@@ -94,6 +265,128 @@ function nat_sorted(arr, ignore_case, reverse) {
 }
 exports.nat_sorted = nat_sorted;
 
+/**
+ * Rolling maximum.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function rolling_max_f64(data, window, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_max_f64(ptr0, len0, window, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_max_f64 = rolling_max_f64;
+
+/**
+ * Rolling arithmetic mean.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function rolling_mean_f64(data, window, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_mean_f64(ptr0, len0, window, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_mean_f64 = rolling_mean_f64;
+
+/**
+ * Rolling median.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function rolling_median_f64(data, window, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_median_f64(ptr0, len0, window, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_median_f64 = rolling_median_f64;
+
+/**
+ * Rolling minimum.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function rolling_min_f64(data, window, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_min_f64(ptr0, len0, window, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_min_f64 = rolling_min_f64;
+
+/**
+ * Rolling standard deviation (delta degrees-of-freedom `ddof`).
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @param {number} ddof
+ * @returns {Float64Array}
+ */
+function rolling_std_f64(data, window, min_periods, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_std_f64(ptr0, len0, window, min_periods, ddof);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_std_f64 = rolling_std_f64;
+
+/**
+ * Rolling sum. Positions with fewer than `min_periods` non-NaN values → NaN.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @returns {Float64Array}
+ */
+function rolling_sum_f64(data, window, min_periods) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_sum_f64(ptr0, len0, window, min_periods);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_sum_f64 = rolling_sum_f64;
+
+/**
+ * Rolling variance (delta degrees-of-freedom `ddof`).
+ * Positions with fewer than `ddof + 1` valid values → NaN.
+ * @param {Float64Array} data
+ * @param {number} window
+ * @param {number} min_periods
+ * @param {number} ddof
+ * @returns {Float64Array}
+ */
+function rolling_var_f64(data, window, min_periods, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rolling_var_f64(ptr0, len0, window, min_periods, ddof);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.rolling_var_f64 = rolling_var_f64;
+
 /**
  * Binary-search a sorted f64 slice for `value`.
  *
@@ -171,6 +464,51 @@ function searchsorted_str(arr, value, side_right) {
     return ret >>> 0;
 }
 exports.searchsorted_str = searchsorted_str;
+
+/**
+ * Sample standard deviation with delta degrees-of-freedom `ddof`.
+ * Returns `NaN` when fewer than `ddof + 1` valid values exist.
+ * @param {Float64Array} data
+ * @param {number} ddof
+ * @returns {number}
+ */
+function std_f64(data, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.std_f64(ptr0, len0, ddof);
+    return ret;
+}
+exports.std_f64 = std_f64;
+
+/**
+ * Sum of non-NaN values. Returns `0.0` when there are no valid values,
+ * matching `Series.sum()` on an all-null / empty series.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function sum_f64(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sum_f64(ptr0, len0);
+    return ret;
+}
+exports.sum_f64 = sum_f64;
+
+/**
+ * Sample variance of non-NaN values with delta degrees-of-freedom `ddof`.
+ * Returns `NaN` when fewer than `ddof + 1` valid values exist, matching
+ * `Series.var(ddof)`.
+ * @param {Float64Array} data
+ * @param {number} ddof
+ * @returns {number}
+ */
+function var_f64(data, ddof) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.var_f64(ptr0, len0, ddof);
+    return ret;
+}
+exports.var_f64 = var_f64;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -212,6 +550,11 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
diff --git a/rust/pkg/tsb_wasm_bg.wasm b/rust/pkg/tsb_wasm_bg.wasm
index 42ed7985..ad520067 100644
Binary files a/rust/pkg/tsb_wasm_bg.wasm and b/rust/pkg/tsb_wasm_bg.wasm differ
diff --git a/rust/pkg/tsb_wasm_bg.wasm.d.ts b/rust/pkg/tsb_wasm_bg.wasm.d.ts
index d73466a4..6a03ac57 100644
--- a/rust/pkg/tsb_wasm_bg.wasm.d.ts
+++ b/rust/pkg/tsb_wasm_bg.wasm.d.ts
@@ -1,15 +1,36 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const expanding_max_f64: (a: number, b: number, c: number) => [number, number];
+export const expanding_mean_f64: (a: number, b: number, c: number) => [number, number];
+export const expanding_median_f64: (a: number, b: number, c: number) => [number, number];
+export const expanding_min_f64: (a: number, b: number, c: number) => [number, number];
+export const expanding_std_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const expanding_sum_f64: (a: number, b: number, c: number) => [number, number];
+export const expanding_var_f64: (a: number, b: number, c: number, d: number) => [number, number];
 export const nat_argsort: (a: number, b: number, c: number, d: number) => [number, number];
 export const nat_compare: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const nat_sorted: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_max_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_mean_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_median_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_min_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_std_f64: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const rolling_sum_f64: (a: number, b: number, c: number, d: number) => [number, number];
+export const rolling_var_f64: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const argsort_f64: (a: number, b: number) => [number, number];
 export const argsort_str: (a: number, b: number) => [number, number];
+export const max_f64: (a: number, b: number) => number;
+export const mean_f64: (a: number, b: number) => number;
+export const median_f64: (a: number, b: number) => number;
+export const min_f64: (a: number, b: number) => number;
 export const searchsorted_f64: (a: number, b: number, c: number, d: number) => number;
 export const searchsorted_many_f64: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const searchsorted_many_str: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const searchsorted_str: (a: number, b: number, c: number, d: number, e: number) => number;
+export const std_f64: (a: number, b: number, c: number) => number;
+export const sum_f64: (a: number, b: number) => number;
+export const var_f64: (a: number, b: number, c: number) => number;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index ba0cc5f0..eb9f03cc 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -7,7 +7,11 @@
  */
 
 mod natsort;
+mod reductions;
+mod rolling;
 mod searchsorted;
 
 pub use natsort::*;
+pub use reductions::*;
+pub use rolling::*;
 pub use searchsorted::*;
diff --git a/rust/src/reductions.rs b/rust/src/reductions.rs
new file mode 100644
index 00000000..e3ee1351
--- /dev/null
+++ b/rust/src/reductions.rs
@@ -0,0 +1,231 @@
+/*!
+ * Scalar reduction accelerators for f64 arrays.
+ *
+ * All functions skip NaN values, matching the TypeScript `_numericValues()`
+ * filter that Series.sum / Series.mean / etc. apply before reducing.
+ *
+ * Conventions:
+ * - Empty or all-NaN input: sum → 0.0, mean/min/max/std/var/median → NaN.
+ * - ddof is the delta degrees-of-freedom for variance/std (1 = sample).
+ */
+
+use wasm_bindgen::prelude::*;
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+/// Collect non-NaN values from `data` into a `Vec<f64>`.
+fn valid(data: &[f64]) -> Vec<f64> {
+    data.iter().filter(|v| !v.is_nan()).copied().collect()
+}
+
+// ─── public exports ───────────────────────────────────────────────────────────
+
+/// Sum of non-NaN values. Returns `0.0` when there are no valid values,
+/// matching `Series.sum()` on an all-null / empty series.
+#[wasm_bindgen]
+pub fn sum_f64(data: &[f64]) -> f64 {
+    let mut acc = 0.0_f64;
+    for &v in data {
+        if !v.is_nan() {
+            acc += v;
+        }
+    }
+    acc
+}
+
+/// Arithmetic mean of non-NaN values. Returns `NaN` for empty / all-NaN input,
+/// matching `Series.mean()`.
+#[wasm_bindgen]
+pub fn mean_f64(data: &[f64]) -> f64 {
+    let mut acc = 0.0_f64;
+    let mut count = 0_u64;
+    for &v in data {
+        if !v.is_nan() {
+            acc += v;
+            count += 1;
+        }
+    }
+    if count == 0 {
+        f64::NAN
+    } else {
+        acc / count as f64
+    }
+}
+
+/// Minimum of non-NaN values. Returns `NaN` for empty / all-NaN input,
+/// matching `Series.min()` returning `undefined` (coerced to NaN in numeric
+/// contexts).
+#[wasm_bindgen]
+pub fn min_f64(data: &[f64]) -> f64 {
+    let mut result = f64::NAN;
+    for &v in data {
+        if !v.is_nan() {
+            if result.is_nan() || v < result {
+                result = v;
+            }
+        }
+    }
+    result
+}
+
+/// Maximum of non-NaN values. Returns `NaN` for empty / all-NaN input.
+#[wasm_bindgen]
+pub fn max_f64(data: &[f64]) -> f64 {
+    let mut result = f64::NAN;
+    for &v in data {
+        if !v.is_nan() {
+            if result.is_nan() || v > result {
+                result = v;
+            }
+        }
+    }
+    result
+}
+
+/// Sample variance of non-NaN values with delta degrees-of-freedom `ddof`.
+/// Returns `NaN` when fewer than `ddof + 1` valid values exist, matching
+/// `Series.var(ddof)`.
+#[wasm_bindgen]
+pub fn var_f64(data: &[f64], ddof: f64) -> f64 {
+    let vals = valid(data);
+    let n = vals.len() as f64;
+    if n < ddof + 1.0 {
+        return f64::NAN;
+    }
+    let mu = vals.iter().sum::<f64>() / n;
+    let ss: f64 = vals.iter().map(|v| (v - mu) * (v - mu)).sum();
+    ss / (n - ddof)
+}
+
+/// Sample standard deviation with delta degrees-of-freedom `ddof`.
+/// Returns `NaN` when fewer than `ddof + 1` valid values exist.
+#[wasm_bindgen]
+pub fn std_f64(data: &[f64], ddof: f64) -> f64 {
+    var_f64(data, ddof).sqrt()
+}
+
+/// Median of non-NaN values (middle value of sorted data; average of two
+/// middle values for even-length arrays). Returns `NaN` for empty / all-NaN
+/// input, matching `Series.median()`.
+#[wasm_bindgen]
+pub fn median_f64(data: &[f64]) -> f64 {
+    let mut vals = valid(data);
+    let n = vals.len();
+    if n == 0 {
+        return f64::NAN;
+    }
+    vals.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+    let mid = n / 2;
+    if n % 2 == 1 {
+        vals[mid]
+    } else {
+        (vals[mid - 1] + vals[mid]) / 2.0
+    }
+}
+
+// ─── unit tests ───────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn assert_near(a: f64, b: f64) {
+        if a.is_nan() && b.is_nan() {
+            return;
+        }
+        assert!(
+            (a - b).abs() < 1e-9,
+            "expected {}, got {}",
+            b,
+            a
+        );
+    }
+
+    #[test]
+    fn test_sum_basic() {
+        assert_near(sum_f64(&[1.0, 2.0, 3.0, 4.0]), 10.0);
+    }
+
+    #[test]
+    fn test_sum_with_nan() {
+        assert_near(sum_f64(&[1.0, f64::NAN, 3.0]), 4.0);
+    }
+
+    #[test]
+    fn test_sum_empty() {
+        assert_near(sum_f64(&[]), 0.0);
+    }
+
+    #[test]
+    fn test_mean_basic() {
+        assert_near(mean_f64(&[1.0, 2.0, 3.0]), 2.0);
+    }
+
+    #[test]
+    fn test_mean_nan_skipped() {
+        assert_near(mean_f64(&[1.0, f64::NAN, 3.0]), 2.0);
+    }
+
+    #[test]
+    fn test_mean_empty() {
+        assert!(mean_f64(&[]).is_nan());
+    }
+
+    #[test]
+    fn test_min_basic() {
+        assert_near(min_f64(&[3.0, 1.0, 4.0, 1.5]), 1.0);
+    }
+
+    #[test]
+    fn test_min_nan_skipped() {
+        assert_near(min_f64(&[f64::NAN, 2.0, f64::NAN]), 2.0);
+    }
+
+    #[test]
+    fn test_min_all_nan() {
+        assert!(min_f64(&[f64::NAN]).is_nan());
+    }
+
+    #[test]
+    fn test_max_basic() {
+        assert_near(max_f64(&[3.0, 1.0, 4.0]), 4.0);
+    }
+
+    #[test]
+    fn test_var_sample() {
+        // [2, 4, 4, 4, 5, 5, 7, 9] — ddof=1
+        let data = vec![2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
+        assert_near(var_f64(&data, 1.0), 4.571428571428571);
+    }
+
+    #[test]
+    fn test_var_too_few() {
+        assert!(var_f64(&[1.0], 1.0).is_nan());
+    }
+
+    #[test]
+    fn test_std_basic() {
+        let data = vec![2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];
+        assert_near(std_f64(&data, 1.0), var_f64(&data, 1.0).sqrt());
+    }
+
+    #[test]
+    fn test_median_odd() {
+        assert_near(median_f64(&[3.0, 1.0, 2.0]), 2.0);
+    }
+
+    #[test]
+    fn test_median_even() {
+        assert_near(median_f64(&[1.0, 2.0, 3.0, 4.0]), 2.5);
+    }
+
+    #[test]
+    fn test_median_nan_skipped() {
+        assert_near(median_f64(&[f64::NAN, 1.0, 3.0]), 2.0);
+    }
+
+    #[test]
+    fn test_median_empty() {
+        assert!(median_f64(&[]).is_nan());
+    }
+}
diff --git a/rust/src/rolling.rs b/rust/src/rolling.rs
new file mode 100644
index 00000000..1ba0df5b
--- /dev/null
+++ b/rust/src/rolling.rs
@@ -0,0 +1,370 @@
+/*!
+ * Sliding-window (rolling) and expanding-window reduction accelerators.
+ *
+ * All functions accept a `Float64Array`, a window size, and a `min_periods`
+ * threshold.  Positions where the count of non-NaN values in the current
+ * window is less than `min_periods` produce `NaN` in the output, matching the
+ * TypeScript `Rolling` / `Expanding` implementations.
+ *
+ * Expanding variants are implemented by passing `window = data.len()` and
+ * resetting `start = 0` every iteration.
+ */
+
+use wasm_bindgen::prelude::*;
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+/// Compute `sum` and `count` of non-NaN values in `data[start..end]`.
+#[inline]
+fn window_sum_count(data: &[f64], start: usize, end: usize) -> (f64, usize) {
+    let mut sum = 0.0_f64;
+    let mut count = 0_usize;
+    for i in start..end {
+        if !data[i].is_nan() {
+            sum += data[i];
+            count += 1;
+        }
+    }
+    (sum, count)
+}
+
+/// Return the median of `nums` (already collected as non-NaN values).
+fn slice_median(nums: &mut Vec<f64>) -> f64 {
+    nums.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+    let n = nums.len();
+    if n % 2 == 1 {
+        nums[n / 2]
+    } else {
+        (nums[n / 2 - 1] + nums[n / 2]) / 2.0
+    }
+}
+
+// ─── rolling window functions ─────────────────────────────────────────────────
+
+/// Rolling sum. Positions with fewer than `min_periods` non-NaN values → NaN.
+#[wasm_bindgen]
+pub fn rolling_sum_f64(data: &[f64], window: u32, min_periods: u32) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let (sum, count) = window_sum_count(data, start, i + 1);
+        if count >= mp {
+            result[i] = sum;
+        }
+    }
+    result
+}
+
+/// Rolling arithmetic mean.
+#[wasm_bindgen]
+pub fn rolling_mean_f64(data: &[f64], window: u32, min_periods: u32) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let (sum, count) = window_sum_count(data, start, i + 1);
+        if count >= mp {
+            result[i] = sum / count as f64;
+        }
+    }
+    result
+}
+
+/// Rolling minimum.
+#[wasm_bindgen]
+pub fn rolling_min_f64(data: &[f64], window: u32, min_periods: u32) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let mut min_val = f64::NAN;
+        let mut count = 0_usize;
+        for j in start..i + 1 {
+            if !data[j].is_nan() {
+                if min_val.is_nan() || data[j] < min_val {
+                    min_val = data[j];
+                }
+                count += 1;
+            }
+        }
+        if count >= mp {
+            result[i] = min_val;
+        }
+    }
+    result
+}
+
+/// Rolling maximum.
+#[wasm_bindgen]
+pub fn rolling_max_f64(data: &[f64], window: u32, min_periods: u32) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let mut max_val = f64::NAN;
+        let mut count = 0_usize;
+        for j in start..i + 1 {
+            if !data[j].is_nan() {
+                if max_val.is_nan() || data[j] > max_val {
+                    max_val = data[j];
+                }
+                count += 1;
+            }
+        }
+        if count >= mp {
+            result[i] = max_val;
+        }
+    }
+    result
+}
+
+/// Rolling variance (delta degrees-of-freedom `ddof`).
+/// Positions with fewer than `ddof + 1` valid values → NaN.
+#[wasm_bindgen]
+pub fn rolling_var_f64(data: &[f64], window: u32, min_periods: u32, ddof: f64) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let mut vals: Vec<f64> = Vec::new();
+        for j in start..i + 1 {
+            if !data[j].is_nan() {
+                vals.push(data[j]);
+            }
+        }
+        let cnt = vals.len() as f64;
+        if vals.len() >= mp && cnt > ddof {
+            let mu = vals.iter().sum::<f64>() / cnt;
+            let ss: f64 = vals.iter().map(|v| (v - mu) * (v - mu)).sum();
+            result[i] = ss / (cnt - ddof);
+        }
+    }
+    result
+}
+
+/// Rolling standard deviation (delta degrees-of-freedom `ddof`).
+#[wasm_bindgen]
+pub fn rolling_std_f64(data: &[f64], window: u32, min_periods: u32, ddof: f64) -> Vec<f64> {
+    rolling_var_f64(data, window, min_periods, ddof)
+        .into_iter()
+        .map(|v| v.sqrt())
+        .collect()
+}
+
+/// Rolling median.
+#[wasm_bindgen]
+pub fn rolling_median_f64(data: &[f64], window: u32, min_periods: u32) -> Vec<f64> {
+    let n = data.len();
+    let w = window as usize;
+    let mp = min_periods as usize;
+    let mut result = vec![f64::NAN; n];
+    for i in 0..n {
+        let start = if i + 1 >= w { i + 1 - w } else { 0 };
+        let mut vals: Vec<f64> = (start..i + 1)
+            .filter(|&j| !data[j].is_nan())
+            .map(|j| data[j])
+            .collect();
+        if vals.len() >= mp {
+            result[i] = slice_median(&mut vals);
+        }
+    }
+    result
+}
+
+// ─── expanding window variants ────────────────────────────────────────────────
+// These reuse the rolling functions with a window equal to the full array
+// length, making the window grow from left for each position (expanding).
+
+/// Expanding sum.
+#[wasm_bindgen]
+pub fn expanding_sum_f64(data: &[f64], min_periods: u32) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_sum_f64(data, n, min_periods)
+}
+
+/// Expanding mean.
+#[wasm_bindgen]
+pub fn expanding_mean_f64(data: &[f64], min_periods: u32) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_mean_f64(data, n, min_periods)
+}
+
+/// Expanding minimum.
+#[wasm_bindgen]
+pub fn expanding_min_f64(data: &[f64], min_periods: u32) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_min_f64(data, n, min_periods)
+}
+
+/// Expanding maximum.
+#[wasm_bindgen]
+pub fn expanding_max_f64(data: &[f64], min_periods: u32) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_max_f64(data, n, min_periods)
+}
+
+/// Expanding variance (delta degrees-of-freedom `ddof`).
+#[wasm_bindgen]
+pub fn expanding_var_f64(data: &[f64], min_periods: u32, ddof: f64) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_var_f64(data, n, min_periods, ddof)
+}
+
+/// Expanding standard deviation (delta degrees-of-freedom `ddof`).
+#[wasm_bindgen]
+pub fn expanding_std_f64(data: &[f64], min_periods: u32, ddof: f64) -> Vec<f64> {
+    expanding_var_f64(data, min_periods, ddof)
+        .into_iter()
+        .map(|v| v.sqrt())
+        .collect()
+}
+
+/// Expanding median.
+#[wasm_bindgen]
+pub fn expanding_median_f64(data: &[f64], min_periods: u32) -> Vec<f64> {
+    let n = data.len() as u32;
+    rolling_median_f64(data, n, min_periods)
+}
+
+// ─── unit tests ───────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn assert_near(a: f64, b: f64) {
+        if a.is_nan() && b.is_nan() {
+            return;
+        }
+        assert!(!a.is_nan(), "expected {}, got NaN", b);
+        assert!(!b.is_nan(), "expected NaN, got {}", a);
+        assert!(
+            (a - b).abs() < 1e-9,
+            "expected {}, got {}",
+            b,
+            a
+        );
+    }
+
+    fn assert_vec_near(actual: &[f64], expected: &[f64]) {
+        assert_eq!(actual.len(), expected.len());
+        for (i, (&a, &e)) in actual.iter().zip(expected.iter()).enumerate() {
+            if e.is_nan() {
+                assert!(a.is_nan(), "pos {}: expected NaN, got {}", i, a);
+            } else {
+                assert_near(a, e);
+            }
+        }
+    }
+
+    #[test]
+    fn test_rolling_sum_basic() {
+        let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = rolling_sum_f64(&data, 3, 3);
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 6.0, 9.0, 12.0],
+        );
+    }
+
+    #[test]
+    fn test_rolling_sum_min_periods_1() {
+        let data = vec![1.0, 2.0, 3.0];
+        let result = rolling_sum_f64(&data, 3, 1);
+        assert_vec_near(&result, &[1.0, 3.0, 6.0]);
+    }
+
+    #[test]
+    fn test_rolling_mean_basic() {
+        let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+        let result = rolling_mean_f64(&data, 3, 3);
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 2.0, 3.0, 4.0],
+        );
+    }
+
+    #[test]
+    fn test_rolling_mean_with_nan() {
+        let data = vec![1.0, f64::NAN, 3.0, 4.0, 5.0];
+        let result = rolling_mean_f64(&data, 3, 2);
+        // window [1,NaN]: 1 valid < 2 → NaN
+        // window [1,NaN,3]: 2 valid → (1+3)/2 = 2
+        // window [NaN,3,4]: 2 valid → 3.5
+        // window [3,4,5]: 3 valid → 4
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 2.0, 3.5, 4.0],
+        );
+    }
+
+    #[test]
+    fn test_rolling_min_basic() {
+        let data = vec![3.0, 1.0, 2.0, 5.0, 4.0];
+        let result = rolling_min_f64(&data, 3, 3);
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 1.0, 1.0, 2.0],
+        );
+    }
+
+    #[test]
+    fn test_rolling_max_basic() {
+        let data = vec![1.0, 3.0, 2.0, 5.0, 4.0];
+        let result = rolling_max_f64(&data, 3, 3);
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 3.0, 5.0, 5.0],
+        );
+    }
+
+    #[test]
+    fn test_rolling_var_basic() {
+        let data = vec![1.0, 2.0, 3.0, 4.0];
+        let result = rolling_var_f64(&data, 3, 3, 1.0);
+        // var([1,2,3]) = 1, var([2,3,4]) = 1
+        assert_vec_near(&result, &[f64::NAN, f64::NAN, 1.0, 1.0]);
+    }
+
+    #[test]
+    fn test_rolling_median_basic() {
+        let data = vec![1.0, 3.0, 2.0, 4.0, 5.0];
+        let result = rolling_median_f64(&data, 3, 3);
+        assert_vec_near(
+            &result,
+            &[f64::NAN, f64::NAN, 2.0, 3.0, 4.0],
+        );
+    }
+
+    #[test]
+    fn test_expanding_sum() {
+        let data = vec![1.0, 2.0, 3.0];
+        let result = expanding_sum_f64(&data, 1);
+        assert_vec_near(&result, &[1.0, 3.0, 6.0]);
+    }
+
+    #[test]
+    fn test_expanding_mean() {
+        let data = vec![1.0, 2.0, 3.0];
+        let result = expanding_mean_f64(&data, 1);
+        assert_vec_near(&result, &[1.0, 1.5, 2.0]);
+    }
+
+    #[test]
+    fn test_expanding_with_nan() {
+        let data = vec![1.0, f64::NAN, 3.0];
+        let result = expanding_sum_f64(&data, 1);
+        assert_vec_near(&result, &[1.0, 1.0, 4.0]);
+    }
+}
diff --git a/scripts/wasm-coverage-check.ts b/scripts/wasm-coverage-check.ts
index 08cf5e4b..aff6cb01 100644
--- a/scripts/wasm-coverage-check.ts
+++ b/scripts/wasm-coverage-check.ts
@@ -1,9 +1,12 @@
 /**
  * Rust/WASM coverage check script.
  *
- * Verifies that `wasm-coverage.json` contains no unclassified entries and no
- * eligible functions that are missing implementations. Exits with a non-zero
- * code and a descriptive error on any violation.
+ * Verifies that `wasm-coverage.json`:
+ * 1. Contains no unclassified entries and no eligible functions without implementations.
+ * 2. Covers every value export from `src/core/index.ts`.
+ * 3. Covers every top-level value export from `src/index.ts` whose source is under `src/core/`.
+ *
+ * Exits with a non-zero code and a descriptive error on any violation.
  *
  * Usage: bun run wasm:coverage
  */
@@ -13,7 +16,8 @@ import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dir = dirname(fileURLToPath(import.meta.url));
-const manifestPath = resolve(__dir, "..", "wasm-coverage.json");
+const repoRoot = resolve(__dir, "..");
+const manifestPath = resolve(repoRoot, "wasm-coverage.json");
 
 let manifest: unknown;
 try {
@@ -46,6 +50,56 @@ if (!isManifest(manifest)) {
 
 const { entries, summary } = manifest;
 
+// ─── extract live export surface ─────────────────────────────────────────────
+
+/**
+ * Parse value (non-type) export names from a TypeScript barrel file.
+ *
+ * Recognises patterns:
+ *   export { Name1, Name2 } from "...";
+ *   export {\n  Name1,\n  Name2,\n} from "...";
+ *
+ * Skips `export type { ... }` blocks entirely.
+ *
+ * Optionally filters to only exports whose source path matches a predicate.
+ */
+function parseValueExports(
+  source: string,
+  sourceFilter?: (fromPath: string) => boolean,
+): Set<string> {
+  const result = new Set<string>();
+  // Match export blocks (possibly multi-line) with their "from" clause
+  const exportBlockRe =
+    /^export\s+(type\s+)?\{([\s\S]*?)\}\s*from\s*["']([^"']+)["']/gm;
+  let m: RegExpExecArray | null;
+  while ((m = exportBlockRe.exec(source)) !== null) {
+    const isTypeExport = m[1] !== undefined; // "type " present
+    if (isTypeExport) continue;
+    const fromPath = m[3];
+    if (sourceFilter && !sourceFilter(fromPath)) continue;
+    const names = m[2].split(",").map((s) => s.trim()).filter(Boolean);
+    for (const name of names) {
+      // Skip inline comments and empty tokens
+      const clean = name.replace(/\/\/.*$/, "").trim();
+      if (!clean || clean.startsWith("//")) continue;
+      result.add(clean);
+    }
+  }
+  return result;
+}
+
+// All value exports from src/core/index.ts
+const coreIndexSource = readFileSync(resolve(repoRoot, "src/core/index.ts"), "utf-8");
+const coreIndexExports = parseValueExports(coreIndexSource);
+
+// Top-level value exports from src/index.ts that come from src/core/** paths
+// (includes both "./core/index.ts" re-exports and direct "./core/foo.ts" exports)
+const indexSource = readFileSync(resolve(repoRoot, "src/index.ts"), "utf-8");
+const topLevelCoreExports = parseValueExports(
+  indexSource,
+  (fromPath) => fromPath.startsWith("./core/"),
+);
+
 // ─── validate each entry ──────────────────────────────────────────────────────
 
 const validStatuses = new Set(["rust-wasm", "ts-only-ineligible"]);
@@ -63,6 +117,15 @@ const eligibleMissing = entries.filter(
 const countedRustWasm = entries.filter((e) => e.status === "rust-wasm").length;
 const countedTsOnly = entries.filter((e) => e.status === "ts-only-ineligible").length;
 
+// ─── export-audit: every live export must be in the manifest ─────────────────
+
+const manifestNames = new Set(entries.map((e) => e.name));
+
+// Union of all core exports that the manifest must cover
+const requiredNames = new Set([...coreIndexExports, ...topLevelCoreExports]);
+
+const missingFromManifest = [...requiredNames].filter((n) => !manifestNames.has(n));
+
 // ─── report ───────────────────────────────────────────────────────────────────
 
 let failed = false;
@@ -114,6 +177,15 @@ if (entries.length !== summary.total_core_entries) {
   failed = true;
 }
 
+if (missingFromManifest.length > 0) {
+  console.error(
+    `ERROR: ${missingFromManifest.length} core export(s) are present in the live source but missing from the manifest:\n` +
+      missingFromManifest.map((n) => `  - ${n}`).join("\n") +
+      "\n  Add each missing name to wasm-coverage.json with a status of rust-wasm or ts-only-ineligible.",
+  );
+  failed = true;
+}
+
 if (failed) {
   process.exit(1);
 }
@@ -126,3 +198,5 @@ console.log(`  rust-wasm          : ${summary.rust_wasm}`);
 console.log(`  ts-only-ineligible : ${summary.ts_only_ineligible}`);
 console.log(`  unclassified       : ${summary.unclassified}`);
 console.log(`  eligible_missing   : ${summary.eligible_missing}`);
+console.log(`  live exports audited: ${requiredNames.size} (${coreIndexExports.size} core/index + ${topLevelCoreExports.size} top-level core re-exports, ${requiredNames.size} unique)`);
+console.log(`  missing from manifest: 0`);
diff --git a/src/core/arrays/datetime_array.ts b/src/core/arrays/datetime_array.ts
index df0d808d..8cd4ad8f 100644
--- a/src/core/arrays/datetime_array.ts
+++ b/src/core/arrays/datetime_array.ts
@@ -250,7 +250,7 @@ export class DatetimeArray {
     const data = this._data;
     const mask = this._mask;
     return {
-      next() {
+      next(): IteratorResult<Timestamp | null, null> {
         if (i >= data.length) {
           return { value: null, done: true };
         }
diff --git a/src/core/arrays/masked_array.ts b/src/core/arrays/masked_array.ts
index 238082a4..f645ca6e 100644
--- a/src/core/arrays/masked_array.ts
+++ b/src/core/arrays/masked_array.ts
@@ -174,7 +174,7 @@ export abstract class MaskedArray<T extends Scalar> {
     const data = this._data;
     const mask = this._mask;
     return {
-      next() {
+      next(): IteratorResult<T | null, null> {
         if (i >= data.length) {
           return { value: null, done: true };
         }
diff --git a/src/core/arrays/timedelta_array.ts b/src/core/arrays/timedelta_array.ts
index 60851c75..2f151175 100644
--- a/src/core/arrays/timedelta_array.ts
+++ b/src/core/arrays/timedelta_array.ts
@@ -308,7 +308,7 @@ export class TimedeltaArray {
     const data = this._data;
     const mask = this._mask;
     return {
-      next() {
+      next(): IteratorResult<Timedelta | null, null> {
         if (i >= data.length) {
           return { value: null, done: true };
         }
diff --git a/src/core/options.ts b/src/core/options.ts
index 628b5cce..a89ab58e 100644
--- a/src/core/options.ts
+++ b/src/core/options.ts
@@ -210,7 +210,10 @@ function _makeProxy(prefix: string): OptionsProxy {
       // If there is a direct match, return its value
       const k = _normalizeKey(key);
       if (_registry.has(k)) {
-        return _registry.get(k)!.currentValue;
+        const entry = _registry.get(k);
+        if (entry !== undefined) {
+          return entry.currentValue;
+        }
       }
       // Otherwise return a nested proxy for deeper access
       return _makeProxy(k);
diff --git a/src/core/series.ts b/src/core/series.ts
index c34d2569..3b4b1608 100644
--- a/src/core/series.ts
+++ b/src/core/series.ts
@@ -34,36 +34,6 @@ function defaultIndex(n: number): Index<Label> {
   return new RangeIndex(n) as unknown as Index<Label>;
 }
 
-/** True when the value should be treated as missing (null, undefined, or NaN). */
-function isMissing(v: Scalar): boolean {
-  return v === null || v === undefined || (typeof v === "number" && Number.isNaN(v));
-}
-
-/** Compare two scalar values with null/NaN handling for sorting. */
-function compareScalars(
-  a: Scalar,
-  b: Scalar,
-  ascending: boolean,
-  naPosition: "first" | "last",
-): number {
-  const aNull = isMissing(a);
-  const bNull = isMissing(b);
-  if (aNull && bNull) {
-    return 0;
-  }
-  if (aNull) {
-    return naPosition === "first" ? -1 : 1;
-  }
-  if (bNull) {
-    return naPosition === "first" ? 1 : -1;
-  }
-  if (a === b) {
-    return 0;
-  }
-  const cmp = (a as number | string | boolean) < (b as number | string | boolean) ? -1 : 1;
-  return ascending ? cmp : -cmp;
-}
-
 /** True when a scalar is a finite number (not null/undefined/NaN). */
 function isFiniteNum(v: Scalar): v is number {
   return typeof v === "number" && !Number.isNaN(v);
@@ -795,34 +765,28 @@ export class Series<T extends Scalar = Scalar> {
 
   // ─── sorting ─────────────────────────────────────────────────────────────
 
-  /** Return a new Series sorted by values. */
-  sortValues(ascending = true, naPosition: "first" | "last" = "last"): Series<T> {
-    // ── Per-instance cache: check ascending first, then naLast inside each branch ──
+  /** Look up per-instance sort cache slot for the given direction and NA position. */
+  private _svCacheGet(ascending: boolean, naPosition: "first" | "last"): Series<T> | null {
     // naPosition.length === 4: "last" has 4 chars, "first" has 5 chars.
     // Nested branches instead of ternary selection let JSC use fully-predicted
     // branches (0-cycle latency when taken) rather than a cmov (3-cycle latency).
     if (ascending) {
       if (naPosition.length === 4) {
-        const hit = this._svCacheAL;
-        if (hit !== null) {
-          return hit;
-        }
-      } else {
-        const hit = this._svCacheAF;
-        if (hit !== null) {
-          return hit;
-        }
-      }
-    } else if (naPosition.length === 4) {
-      const hit = this._svCacheDL;
-      if (hit !== null) {
-        return hit;
-      }
-    } else {
-      const hit = this._svCacheDF;
-      if (hit !== null) {
-        return hit;
+        return this._svCacheAL;
       }
+      return this._svCacheAF;
+    }
+    if (naPosition.length === 4) {
+      return this._svCacheDL;
+    }
+    return this._svCacheDF;
+  }
+
+  /** Return a new Series sorted by values. */
+  sortValues(ascending = true, naPosition: "first" | "last" = "last"): Series<T> {
+    const hit = this._svCacheGet(ascending, naPosition);
+    if (hit !== null) {
+      return hit;
     }
     return this._sortValuesCold(ascending, naPosition);
   }
@@ -900,8 +864,8 @@ export class Series<T extends Scalar = Scalar> {
           if (typeof v === "number") {
             fvals[j] = v;
             // Read the IEEE-754 bits via the shared Uint32 view (same buffer, no copy).
-            let lo = fvalsU32[fsi]!;
-            let hi = fvalsU32[fsi + 1]!;
+            let lo = fvalsU32[fsi] ?? 0;
+            let hi = fvalsU32[fsi + 1] ?? 0;
             // Transform floats to sortable unsigned integers:
             // positive → XOR sign bit; negative → XOR all bits.
             if (hi & 0x80000000) {
@@ -918,21 +882,21 @@ export class Series<T extends Scalar = Scalar> {
             // Accumulate all 8 histogram passes inline — no second scan needed.
             let idx: number;
             idx = lo & 0xff;
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 256 + ((lo >>> 8) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 512 + ((lo >>> 16) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 768 + ((lo >>> 24) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 1024 + (hi & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 1280 + ((hi >>> 8) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 1536 + ((hi >>> 16) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
             idx = 1792 + ((hi >>> 24) & 0xff);
-            _rxHisto[idx] = _rxHisto[idx]! + 1;
+            _rxHisto[idx] = (_rxHisto[idx] ?? 0) + 1;
           } else {
             allNumeric = false;
           }
@@ -957,7 +921,7 @@ export class Series<T extends Scalar = Scalar> {
           const base = pass * 256;
           let total = 0;
           for (let b = 0; b < 256; b++) {
-            const c = _rxHisto[base + b]!;
+            const c = _rxHisto[base + b] ?? 0;
             _rxHisto[base + b] = total;
             total += c;
           }
@@ -973,14 +937,14 @@ export class Series<T extends Scalar = Scalar> {
           const histoBase = pass * 256;
           // Use accumulated stride counter (si += 3) to avoid i*3 multiply per element.
           for (let i = 0, si = 0; i < finCount; i++, si += 3) {
-            const bucket = (srcBuf[si + keyOff]! >>> shift) & 0xff;
-            const p = _rxHisto[histoBase + bucket]!;
+            const bucket = ((srcBuf[si + keyOff] ?? 0) >>> shift) & 0xff;
+            const p = _rxHisto[histoBase + bucket] ?? 0;
             _rxHisto[histoBase + bucket] = p + 1;
             // All three writes land on the same cache line (3 × 4 = 12 bytes).
             const di = p * 3;
-            dstBuf[di] = srcBuf[si]!;
-            dstBuf[di + 1] = srcBuf[si + 1]!;
-            dstBuf[di + 2] = srcBuf[si + 2]!;
+            dstBuf[di] = srcBuf[si] ?? 0;
+            dstBuf[di + 1] = srcBuf[si + 1] ?? 0;
+            dstBuf[di + 2] = srcBuf[si + 2] ?? 0;
           }
           const t = srcBuf;
           srcBuf = dstBuf;
@@ -993,13 +957,25 @@ export class Series<T extends Scalar = Scalar> {
           finSlice.sort((a, b) => {
             const av = vals[a] as number | string | boolean;
             const bv = vals[b] as number | string | boolean;
-            return av < bv ? -1 : av > bv ? 1 : 0;
+            if (av < bv) {
+              return -1;
+            }
+            if (av > bv) {
+              return 1;
+            }
+            return 0;
           });
         } else {
           finSlice.sort((a, b) => {
             const av = vals[a] as number | string | boolean;
             const bv = vals[b] as number | string | boolean;
-            return av > bv ? -1 : av < bv ? 1 : 0;
+            if (av > bv) {
+              return -1;
+            }
+            if (av < bv) {
+              return 1;
+            }
+            return 0;
           });
         }
       }
@@ -1053,9 +1029,9 @@ export class Series<T extends Scalar = Scalar> {
       if (allNumeric) {
         if (ascending) {
           for (let i = 0, si = 0; i < finCount; i++, si += 3) {
-            const origIdx = srcBuf[si]!;
-            const keyLo = srcBuf[si + 1]!;
-            const keyHi = srcBuf[si + 2]!;
+            const origIdx = srcBuf[si] ?? 0;
+            const keyLo = srcBuf[si + 1] ?? 0;
+            const keyHi = srcBuf[si + 2] ?? 0;
             perm[pos] = origIdx;
             // Reverse the IEEE-754 sign-transform to recover the original float bits,
             // avoiding a random read into the JS values array.
@@ -1071,9 +1047,9 @@ export class Series<T extends Scalar = Scalar> {
           }
         } else {
           for (let i = finCount - 1, si = (finCount - 1) * 3; i >= 0; i--, si -= 3) {
-            const origIdx = srcBuf[si]!;
-            const keyLo = srcBuf[si + 1]!;
-            const keyHi = srcBuf[si + 2]!;
+            const origIdx = srcBuf[si] ?? 0;
+            const keyLo = srcBuf[si + 1] ?? 0;
+            const keyHi = srcBuf[si + 2] ?? 0;
             perm[pos] = origIdx;
             if (keyHi & 0x80000000) {
               _fvalsU32[0] = keyLo;
@@ -1088,21 +1064,21 @@ export class Series<T extends Scalar = Scalar> {
         }
       } else {
         for (let i = 0; i < finCount; i++) {
-          const idx = finSlice[i]!;
+          const idx = finSlice[i] ?? 0;
           perm[pos] = idx;
           outData[pos] = vals[idx] as T;
           pos += 1;
         }
       }
       for (let i = 0; i < nanCount; i++) {
-        const idx = nanBuf[i]!;
+        const idx = nanBuf[i] ?? 0;
         perm[pos] = idx;
         outData[pos] = vals[idx] as T;
         pos += 1;
       }
     } else {
       for (let i = 0; i < nanCount; i++) {
-        const idx = nanBuf[i]!;
+        const idx = nanBuf[i] ?? 0;
         perm[pos] = idx;
         outData[pos] = vals[idx] as T;
         pos += 1;
@@ -1110,9 +1086,9 @@ export class Series<T extends Scalar = Scalar> {
       if (allNumeric) {
         if (ascending) {
           for (let i = 0, si = 0; i < finCount; i++, si += 3) {
-            const origIdx = srcBuf[si]!;
-            const keyLo = srcBuf[si + 1]!;
-            const keyHi = srcBuf[si + 2]!;
+            const origIdx = srcBuf[si] ?? 0;
+            const keyLo = srcBuf[si + 1] ?? 0;
+            const keyHi = srcBuf[si + 2] ?? 0;
             perm[pos] = origIdx;
             if (keyHi & 0x80000000) {
               _fvalsU32[0] = keyLo;
@@ -1126,9 +1102,9 @@ export class Series<T extends Scalar = Scalar> {
           }
         } else {
           for (let i = finCount - 1, si = (finCount - 1) * 3; i >= 0; i--, si -= 3) {
-            const origIdx = srcBuf[si]!;
-            const keyLo = srcBuf[si + 1]!;
-            const keyHi = srcBuf[si + 2]!;
+            const origIdx = srcBuf[si] ?? 0;
+            const keyLo = srcBuf[si + 1] ?? 0;
+            const keyHi = srcBuf[si + 2] ?? 0;
             perm[pos] = origIdx;
             if (keyHi & 0x80000000) {
               _fvalsU32[0] = keyLo;
@@ -1143,7 +1119,7 @@ export class Series<T extends Scalar = Scalar> {
         }
       } else {
         for (let i = 0; i < finCount; i++) {
-          const idx = finSlice[i]!;
+          const idx = finSlice[i] ?? 0;
           perm[pos] = idx;
           outData[pos] = vals[idx] as T;
           pos += 1;
diff --git a/src/core/timestamp.ts b/src/core/timestamp.ts
index f6d0a5bf..c0ec0a89 100644
--- a/src/core/timestamp.ts
+++ b/src/core/timestamp.ts
@@ -383,6 +383,8 @@ function parseString(
 
 // ─── frequency helpers for floor/ceil/round ───────────────────────────────────
 
+const RE_FREQ_NUNIT = /^(\d+)(.+)$/;
+
 /** Return the size of a frequency in milliseconds. */
 function freqMs(freq: string): number {
   const upper = freq.toUpperCase();
@@ -408,7 +410,7 @@ function freqMs(freq: string): number {
     return MS_PER_DAY;
   }
   // Try "Nunit" pattern (e.g. "2H", "15T").
-  const m = /^(\d+)(.+)$/.exec(freq);
+  const m = RE_FREQ_NUNIT.exec(freq);
   if (m !== null && m[1] !== undefined && m[2] !== undefined) {
     return Number(m[1]) * freqMs(m[2]);
   }
diff --git a/src/core/to_from_dict.ts b/src/core/to_from_dict.ts
index 22acf744..1564440a 100644
--- a/src/core/to_from_dict.ts
+++ b/src/core/to_from_dict.ts
@@ -103,90 +103,105 @@ export function toDictOriented(
   df: DataFrame,
   orient: ToDictOrient = "dict",
 ): Record<string, unknown> | unknown[] | DictSplit | DictTight {
-  const colNames = [...df.columns.values];
-  const rowLabels = [...(df.index.values as Label[])];
-  const nRows = df.index.size;
-
   switch (orient) {
     case "dict":
-    case "columns": {
-      const result: Record<string, Record<string, Scalar>> = {};
-      for (const col of colNames) {
-        const series = df.col(col);
-        const colObj: Record<string, Scalar> = {};
-        for (let i = 0; i < nRows; i++) {
-          const lbl = rowLabels[i];
-          const key = labelKey(lbl !== undefined ? lbl : null);
-          colObj[key] = (series.values[i] ?? null) as Scalar;
-        }
-        result[col] = colObj;
-      }
-      return result;
+    case "columns":
+      return toDictColumns(df);
+    case "list":
+      return toDictList(df);
+    case "series":
+      return toDictSeries(df);
+    case "split":
+      return toDictSplit(df);
+    case "tight":
+      return toDictTight(df);
+    case "records":
+      return df.toRecords();
+    case "index":
+      return toDictIndex(df);
+    default: {
+      const exhaustive: never = orient;
+      throw new RangeError(`Unknown orient: ${String(exhaustive)}`);
     }
+  }
+}
 
-    case "list": {
-      const result: Record<string, Scalar[]> = {};
-      for (const col of colNames) {
-        result[col] = [...(df.col(col).values as readonly Scalar[])];
-      }
-      return result;
+function toDictColumns(df: DataFrame): Record<string, Record<string, Scalar>> {
+  const colNames = [...df.columns.values];
+  const rowLabels = [...(df.index.values as Label[])];
+  const nRows = df.index.size;
+  const result: Record<string, Record<string, Scalar>> = {};
+  for (const col of colNames) {
+    const series = df.col(col);
+    const colObj: Record<string, Scalar> = {};
+    for (let i = 0; i < nRows; i++) {
+      const lbl = rowLabels[i];
+      colObj[labelKey(lbl !== undefined ? lbl : null)] = (series.values[i] ?? null) as Scalar;
     }
+    result[col] = colObj;
+  }
+  return result;
+}
 
-    case "series": {
-      const result: Record<string, Series<Scalar>> = {};
-      for (const col of colNames) {
-        result[col] = df.col(col);
-      }
-      return result;
-    }
+function toDictList(df: DataFrame): Record<string, Scalar[]> {
+  const result: Record<string, Scalar[]> = {};
+  for (const col of df.columns.values) {
+    result[col] = [...(df.col(col).values as readonly Scalar[])];
+  }
+  return result;
+}
 
-    case "split": {
-      const data: Scalar[][] = [];
-      for (let i = 0; i < nRows; i++) {
-        const row: Scalar[] = colNames.map((col) => (df.col(col).values[i] ?? null) as Scalar);
-        data.push(row);
-      }
-      return { index: rowLabels, columns: colNames, data } satisfies DictSplit;
-    }
+function toDictSeries(df: DataFrame): Record<string, Series<Scalar>> {
+  const result: Record<string, Series<Scalar>> = {};
+  for (const col of df.columns.values) {
+    result[col] = df.col(col);
+  }
+  return result;
+}
 
-    case "tight": {
-      const data: Scalar[][] = [];
-      for (let i = 0; i < nRows; i++) {
-        const row: Scalar[] = colNames.map((col) => (df.col(col).values[i] ?? null) as Scalar);
-        data.push(row);
-      }
-      return {
-        index: rowLabels,
-        columns: colNames,
-        data,
-        index_names: [null],
-        column_names: [null],
-      } satisfies DictTight;
-    }
+function buildRows(df: DataFrame): Scalar[][] {
+  const colNames = [...df.columns.values];
+  const nRows = df.index.size;
+  const data: Scalar[][] = [];
+  for (let i = 0; i < nRows; i++) {
+    data.push(colNames.map((col) => (df.col(col).values[i] ?? null) as Scalar));
+  }
+  return data;
+}
 
-    case "records": {
-      return df.toRecords();
-    }
+function toDictSplit(df: DataFrame): DictSplit {
+  return {
+    index: [...(df.index.values as Label[])],
+    columns: [...df.columns.values],
+    data: buildRows(df),
+  } satisfies DictSplit;
+}
 
-    case "index": {
-      const result: Record<string, Record<string, Scalar>> = {};
-      for (let i = 0; i < nRows; i++) {
-        const lbl = rowLabels[i];
-        const key = labelKey(lbl !== undefined ? lbl : null);
-        const rowObj: Record<string, Scalar> = {};
-        for (const col of colNames) {
-          rowObj[col] = (df.col(col).values[i] ?? null) as Scalar;
-        }
-        result[key] = rowObj;
-      }
-      return result;
-    }
+function toDictTight(df: DataFrame): DictTight {
+  return {
+    index: [...(df.index.values as Label[])],
+    columns: [...df.columns.values],
+    data: buildRows(df),
+    index_names: [null],
+    column_names: [null],
+  } satisfies DictTight;
+}
 
-    default: {
-      const exhaustive: never = orient;
-      throw new RangeError(`Unknown orient: ${String(exhaustive)}`);
+function toDictIndex(df: DataFrame): Record<string, Record<string, Scalar>> {
+  const colNames = [...df.columns.values];
+  const rowLabels = [...(df.index.values as Label[])];
+  const nRows = df.index.size;
+  const result: Record<string, Record<string, Scalar>> = {};
+  for (let i = 0; i < nRows; i++) {
+    const lbl = rowLabels[i];
+    const key = labelKey(lbl !== undefined ? lbl : null);
+    const rowObj: Record<string, Scalar> = {};
+    for (const col of colNames) {
+      rowObj[col] = (df.col(col).values[i] ?? null) as Scalar;
     }
+    result[key] = rowObj;
   }
+  return result;
 }
 
 // ─── fromDictOriented ─────────────────────────────────────────────────────────
@@ -224,33 +239,7 @@ export function fromDictOriented(data: unknown, orient: FromDictOrient = "column
 
     case "index": {
       const indexData = data as Record<string, Record<string, Scalar>>;
-      const rowLabels = Object.keys(indexData);
-      // Collect all column names in insertion order
-      const colSet = new Map<string, null>();
-      for (const rowLabel of rowLabels) {
-        const rowObj = indexData[rowLabel];
-        if (rowObj !== undefined) {
-          for (const col of Object.keys(rowObj)) {
-            colSet.set(col, null);
-          }
-        }
-      }
-      const colNames = [...colSet.keys()];
-      const colArrays: Record<string, Scalar[]> = {};
-      for (const col of colNames) {
-        colArrays[col] = [];
-      }
-      for (const rowLabel of rowLabels) {
-        const rowObj = indexData[rowLabel] ?? {};
-        for (const col of colNames) {
-          const arr = colArrays[col];
-          if (arr !== undefined) {
-            arr.push(rowObj[col] ?? null);
-          }
-        }
-      }
-      const idx = new Index<Label>(rowLabels as Label[]);
-      return DataFrame.fromColumns(colArrays as Record<string, readonly Scalar[]>, { index: idx });
+      return buildFromIndex(indexData);
     }
 
     case "split":
@@ -267,6 +256,52 @@ export function fromDictOriented(data: unknown, orient: FromDictOrient = "column
 
 // ─── internal helpers ──────────────────────────────────────────────────────────
 
+/** Build a DataFrame from an index-oriented rowLabel -> column -> value mapping. */
+function buildFromIndex(indexData: Record<string, Record<string, Scalar>>): DataFrame {
+  const rowLabels = Object.keys(indexData);
+  const colNames = collectIndexColumns(indexData, rowLabels);
+  const colArrays = buildIndexColumnArrays(indexData, rowLabels, colNames);
+  const idx = new Index<Label>(rowLabels as Label[]);
+  return DataFrame.fromColumns(colArrays as Record<string, readonly Scalar[]>, { index: idx });
+}
+
+function collectIndexColumns(
+  indexData: Record<string, Record<string, Scalar>>,
+  rowLabels: readonly string[],
+): string[] {
+  const colSet = new Map<string, null>();
+  for (const rowLabel of rowLabels) {
+    const rowObj = indexData[rowLabel];
+    if (rowObj !== undefined) {
+      for (const col of Object.keys(rowObj)) {
+        colSet.set(col, null);
+      }
+    }
+  }
+  return [...colSet.keys()];
+}
+
+function buildIndexColumnArrays(
+  indexData: Record<string, Record<string, Scalar>>,
+  rowLabels: readonly string[],
+  colNames: readonly string[],
+): Record<string, Scalar[]> {
+  const colArrays: Record<string, Scalar[]> = {};
+  for (const col of colNames) {
+    colArrays[col] = [];
+  }
+  for (const rowLabel of rowLabels) {
+    const rowObj = indexData[rowLabel] ?? {};
+    for (const col of colNames) {
+      const arr = colArrays[col];
+      if (arr !== undefined) {
+        arr.push(rowObj[col] ?? null);
+      }
+    }
+  }
+  return colArrays;
+}
+
 /** Build a DataFrame from a split/tight structure. */
 function buildFromSplit(input: SplitInput): DataFrame {
   const { columns, data } = input;
diff --git a/src/wasm/accelerated.ts b/src/wasm/accelerated.ts
index e8ebc510..37af06d1 100644
--- a/src/wasm/accelerated.ts
+++ b/src/wasm/accelerated.ts
@@ -137,3 +137,418 @@ export function natArgSortAccelerated(arr: readonly string[], opts: NatSortOptio
   }
   return tsNA(arr, opts);
 }
+
+// ─── scalar reduction accelerated helpers ─────────────────────────────────────
+
+/**
+ * Accelerated sum of a numeric array (non-NaN values only).
+ * Matches `Series.sum()` semantics: returns `0` for empty input.
+ * Falls back to a TypeScript loop if WASM is unavailable.
+ */
+export function sumF64Accelerated(nums: readonly number[]): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.sum_f64(new Float64Array(nums));
+  }
+  let acc = 0;
+  for (const v of nums) {
+    if (!Number.isNaN(v)) acc += v;
+  }
+  return acc;
+}
+
+/**
+ * Accelerated arithmetic mean (non-NaN values). Returns `NaN` for empty input.
+ * Falls back to TypeScript when WASM is unavailable.
+ */
+export function meanF64Accelerated(nums: readonly number[]): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.mean_f64(new Float64Array(nums));
+  }
+  let acc = 0;
+  let count = 0;
+  for (const v of nums) {
+    if (!Number.isNaN(v)) {
+      acc += v;
+      count++;
+    }
+  }
+  return count === 0 ? Number.NaN : acc / count;
+}
+
+/**
+ * Accelerated minimum (non-NaN values). Returns `NaN` for empty input.
+ */
+export function minF64Accelerated(nums: readonly number[]): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.min_f64(new Float64Array(nums));
+  }
+  let result = Number.NaN;
+  for (const v of nums) {
+    if (!Number.isNaN(v) && (Number.isNaN(result) || v < result)) result = v;
+  }
+  return result;
+}
+
+/**
+ * Accelerated maximum (non-NaN values). Returns `NaN` for empty input.
+ */
+export function maxF64Accelerated(nums: readonly number[]): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.max_f64(new Float64Array(nums));
+  }
+  let result = Number.NaN;
+  for (const v of nums) {
+    if (!Number.isNaN(v) && (Number.isNaN(result) || v > result)) result = v;
+  }
+  return result;
+}
+
+/**
+ * Accelerated sample variance with delta degrees-of-freedom `ddof`.
+ * Returns `NaN` when fewer than `ddof + 1` valid values exist.
+ */
+export function varF64Accelerated(nums: readonly number[], ddof = 1): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.var_f64(new Float64Array(nums), ddof);
+  }
+  const valid = nums.filter((v) => !Number.isNaN(v));
+  const n = valid.length;
+  if (n < ddof + 1) return Number.NaN;
+  const mu = valid.reduce((s, v) => s + v, 0) / n;
+  return valid.reduce((s, v) => s + (v - mu) ** 2, 0) / (n - ddof);
+}
+
+/**
+ * Accelerated sample standard deviation with delta degrees-of-freedom `ddof`.
+ */
+export function stdF64Accelerated(nums: readonly number[], ddof = 1): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.std_f64(new Float64Array(nums), ddof);
+  }
+  return Math.sqrt(varF64Accelerated(nums, ddof));
+}
+
+/**
+ * Accelerated median (non-NaN values, middle or average of two middles).
+ * Returns `NaN` for empty input.
+ */
+export function medianF64Accelerated(nums: readonly number[]): number {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    return wasm.median_f64(new Float64Array(nums));
+  }
+  const sorted = nums.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);
+  const n = sorted.length;
+  if (n === 0) return Number.NaN;
+  const mid = Math.floor(n / 2);
+  const midVal = sorted[mid] ?? Number.NaN;
+  const lo = sorted[mid - 1] ?? Number.NaN;
+  return n % 2 === 1 ? midVal : (lo + midVal) / 2;
+}
+
+// ─── rolling window accelerated helpers ───────────────────────────────────────
+
+/** Convert a Float64Array (NaN = missing) to nullable number[]. */
+function f64ArrayToNullable(arr: Float64Array): (number | null)[] {
+  return Array.from(arr, (v) => (Number.isNaN(v) ? null : v));
+}
+
+/**
+ * Accelerated rolling sum. Returns an array where positions with fewer than
+ * `minPeriods` non-NaN values in the window are `null`.
+ */
+export function rollingSumF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_sum_f64(input, window, minPeriods));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => w.reduce((a, v) => a + v, 0));
+}
+
+/**
+ * Accelerated rolling mean.
+ */
+export function rollingMeanF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_mean_f64(input, window, minPeriods));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => w.reduce((a, v) => a + v, 0) / w.length);
+}
+
+/**
+ * Accelerated rolling minimum.
+ */
+export function rollingMinF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_min_f64(input, window, minPeriods));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => Math.min(...w));
+}
+
+/**
+ * Accelerated rolling maximum.
+ */
+export function rollingMaxF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_max_f64(input, window, minPeriods));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => Math.max(...w));
+}
+
+/**
+ * Accelerated rolling variance (delta degrees-of-freedom `ddof`).
+ */
+export function rollingVarF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+  ddof = 1,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_var_f64(input, window, minPeriods, ddof));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => {
+    const n = w.length;
+    if (n <= ddof) return Number.NaN;
+    const mu = w.reduce((s, v) => s + v, 0) / n;
+    return w.reduce((s, v) => s + (v - mu) ** 2, 0) / (n - ddof);
+  });
+}
+
+/**
+ * Accelerated rolling standard deviation (delta degrees-of-freedom `ddof`).
+ */
+export function rollingStdF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+  ddof = 1,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_std_f64(input, window, minPeriods, ddof));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => {
+    const n = w.length;
+    if (n <= ddof) return Number.NaN;
+    const mu = w.reduce((s, v) => s + v, 0) / n;
+    return Math.sqrt(w.reduce((s, v) => s + (v - mu) ** 2, 0) / (n - ddof));
+  });
+}
+
+/**
+ * Accelerated rolling median.
+ */
+export function rollingMedianF64Accelerated(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.rolling_median_f64(input, window, minPeriods));
+  }
+  return rollingFallback(data, window, minPeriods, (w) => {
+    const s = [...w].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 === 1
+      ? (s[mid] as number)
+      : ((s[mid - 1] as number) + (s[mid] as number)) / 2;
+  });
+}
+
+// ─── expanding window accelerated helpers ─────────────────────────────────────
+
+/**
+ * Accelerated expanding sum.
+ */
+export function expandingSumF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_sum_f64(input, minPeriods));
+  }
+  return rollingFallback(data, data.length, minPeriods, (w) => w.reduce((a, v) => a + v, 0), true);
+}
+
+/**
+ * Accelerated expanding mean.
+ */
+export function expandingMeanF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_mean_f64(input, minPeriods));
+  }
+  const meanFn = (w: number[]) => w.reduce((a, v) => a + v, 0) / w.length;
+  return rollingFallback(data, data.length, minPeriods, meanFn, true);
+}
+
+/**
+ * Accelerated expanding minimum.
+ */
+export function expandingMinF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_min_f64(input, minPeriods));
+  }
+  return rollingFallback(data, data.length, minPeriods, (w) => Math.min(...w), true);
+}
+
+/**
+ * Accelerated expanding maximum.
+ */
+export function expandingMaxF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_max_f64(input, minPeriods));
+  }
+  return rollingFallback(data, data.length, minPeriods, (w) => Math.max(...w), true);
+}
+
+/**
+ * Accelerated expanding variance.
+ */
+export function expandingVarF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+  ddof = 1,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_var_f64(input, minPeriods, ddof));
+  }
+  return rollingFallback(
+    data,
+    data.length,
+    minPeriods,
+    (w) => {
+      const n = w.length;
+      if (n <= ddof) return Number.NaN;
+      const mu = w.reduce((s, v) => s + v, 0) / n;
+      return w.reduce((s, v) => s + (v - mu) ** 2, 0) / (n - ddof);
+    },
+    true,
+  );
+}
+
+/**
+ * Accelerated expanding standard deviation.
+ */
+export function expandingStdF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+  ddof = 1,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_std_f64(input, minPeriods, ddof));
+  }
+  return rollingFallback(
+    data,
+    data.length,
+    minPeriods,
+    (w) => {
+      const n = w.length;
+      if (n <= ddof) return Number.NaN;
+      const mu = w.reduce((s, v) => s + v, 0) / n;
+      return Math.sqrt(w.reduce((s, v) => s + (v - mu) ** 2, 0) / (n - ddof));
+    },
+    true,
+  );
+}
+
+/**
+ * Accelerated expanding median.
+ */
+export function expandingMedianF64Accelerated(
+  data: readonly number[],
+  minPeriods: number,
+): (number | null)[] {
+  const wasm = getWasm();
+  if (wasm !== null) {
+    const input = Float64Array.from(data, (v) => (v === null || v === undefined ? Number.NaN : v));
+    return f64ArrayToNullable(wasm.expanding_median_f64(input, minPeriods));
+  }
+  return rollingFallback(
+    data,
+    data.length,
+    minPeriods,
+    (w) => {
+      const s = [...w].sort((a, b) => a - b);
+      const mid = Math.floor(s.length / 2);
+      return s.length % 2 === 1
+        ? (s[mid] as number)
+        : ((s[mid - 1] as number) + (s[mid] as number)) / 2;
+    },
+    true,
+  );
+}
+
+// ─── rolling fallback helper ──────────────────────────────────────────────────
+
+/** TypeScript fallback for rolling/expanding aggregations. */
+function rollingFallback(
+  data: readonly number[],
+  window: number,
+  minPeriods: number,
+  agg: (window: number[]) => number,
+  expanding = false,
+): (number | null)[] {
+  return data.map((_, i) => {
+    const start = expanding ? 0 : Math.max(0, i + 1 - window);
+    const slice = data.slice(start, i + 1).filter((v) => !Number.isNaN(v));
+    if (slice.length < minPeriods) return null;
+    const result = agg(slice);
+    return Number.isNaN(result) ? null : result;
+  });
+}
diff --git a/src/wasm/index.ts b/src/wasm/index.ts
index 3f14a764..24f9855f 100644
--- a/src/wasm/index.ts
+++ b/src/wasm/index.ts
@@ -14,4 +14,25 @@ export {
   natCompareAccelerated,
   natSortedAccelerated,
   natArgSortAccelerated,
+  sumF64Accelerated,
+  meanF64Accelerated,
+  minF64Accelerated,
+  maxF64Accelerated,
+  varF64Accelerated,
+  stdF64Accelerated,
+  medianF64Accelerated,
+  rollingSumF64Accelerated,
+  rollingMeanF64Accelerated,
+  rollingMinF64Accelerated,
+  rollingMaxF64Accelerated,
+  rollingVarF64Accelerated,
+  rollingStdF64Accelerated,
+  rollingMedianF64Accelerated,
+  expandingSumF64Accelerated,
+  expandingMeanF64Accelerated,
+  expandingMinF64Accelerated,
+  expandingMaxF64Accelerated,
+  expandingVarF64Accelerated,
+  expandingStdF64Accelerated,
+  expandingMedianF64Accelerated,
 } from "./accelerated.ts";
diff --git a/src/wasm/loader.ts b/src/wasm/loader.ts
index 6104e1e5..24dc3cd9 100644
--- a/src/wasm/loader.ts
+++ b/src/wasm/loader.ts
@@ -43,7 +43,28 @@ function isTsbWasmModule(mod: unknown): mod is TsbWasmModule {
     hasFn(mod, "argsort_str") &&
     hasFn(mod, "nat_compare") &&
     hasFn(mod, "nat_sorted") &&
-    hasFn(mod, "nat_argsort")
+    hasFn(mod, "nat_argsort") &&
+    hasFn(mod, "sum_f64") &&
+    hasFn(mod, "mean_f64") &&
+    hasFn(mod, "min_f64") &&
+    hasFn(mod, "max_f64") &&
+    hasFn(mod, "var_f64") &&
+    hasFn(mod, "std_f64") &&
+    hasFn(mod, "median_f64") &&
+    hasFn(mod, "rolling_sum_f64") &&
+    hasFn(mod, "rolling_mean_f64") &&
+    hasFn(mod, "rolling_min_f64") &&
+    hasFn(mod, "rolling_max_f64") &&
+    hasFn(mod, "rolling_var_f64") &&
+    hasFn(mod, "rolling_std_f64") &&
+    hasFn(mod, "rolling_median_f64") &&
+    hasFn(mod, "expanding_sum_f64") &&
+    hasFn(mod, "expanding_mean_f64") &&
+    hasFn(mod, "expanding_min_f64") &&
+    hasFn(mod, "expanding_max_f64") &&
+    hasFn(mod, "expanding_var_f64") &&
+    hasFn(mod, "expanding_std_f64") &&
+    hasFn(mod, "expanding_median_f64")
   );
 }
 
diff --git a/src/wasm/types.ts b/src/wasm/types.ts
index 1e37fb3f..0b4d7f07 100644
--- a/src/wasm/types.ts
+++ b/src/wasm/types.ts
@@ -55,6 +55,135 @@ export interface TsbWasmModule {
   /** Return the indices that would sort a string array lexicographically. */
   readonly argsort_str: (arr: string[]) => Uint32Array;
 
+  // ── scalar reductions ────────────────────────────────────────────────────────
+
+  /**
+   * Sum of non-NaN values in `data`. Returns `0` when all values are NaN
+   * or the array is empty, matching `Series.sum()` semantics.
+   */
+  readonly sum_f64: (data: Float64Array) => number;
+
+  /**
+   * Arithmetic mean of non-NaN values. Returns `NaN` for empty / all-NaN
+   * input, matching `Series.mean()`.
+   */
+  readonly mean_f64: (data: Float64Array) => number;
+
+  /**
+   * Minimum of non-NaN values. Returns `NaN` for empty / all-NaN input,
+   * matching `Series.min()` returning `undefined`.
+   */
+  readonly min_f64: (data: Float64Array) => number;
+
+  /**
+   * Maximum of non-NaN values. Returns `NaN` for empty / all-NaN input.
+   */
+  readonly max_f64: (data: Float64Array) => number;
+
+  /**
+   * Sample variance with delta degrees-of-freedom `ddof`.
+   * Returns `NaN` when fewer than `ddof + 1` valid values exist.
+   */
+  readonly var_f64: (data: Float64Array, ddof: number) => number;
+
+  /**
+   * Sample standard deviation with delta degrees-of-freedom `ddof`.
+   * Returns `NaN` when fewer than `ddof + 1` valid values exist.
+   */
+  readonly std_f64: (data: Float64Array, ddof: number) => number;
+
+  /**
+   * Median of non-NaN values. Returns `NaN` for empty / all-NaN input.
+   */
+  readonly median_f64: (data: Float64Array) => number;
+
+  // ── rolling window functions ──────────────────────────────────────────────
+
+  /**
+   * Rolling sum. Returns `NaN` at positions with fewer than `min_periods`
+   * non-NaN values in the window.
+   */
+  readonly rolling_sum_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+  ) => Float64Array;
+
+  /** Rolling arithmetic mean. */
+  readonly rolling_mean_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+  ) => Float64Array;
+
+  /** Rolling minimum. */
+  readonly rolling_min_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+  ) => Float64Array;
+
+  /** Rolling maximum. */
+  readonly rolling_max_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+  ) => Float64Array;
+
+  /** Rolling variance with delta degrees-of-freedom `ddof`. */
+  readonly rolling_var_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+    ddof: number,
+  ) => Float64Array;
+
+  /** Rolling standard deviation with delta degrees-of-freedom `ddof`. */
+  readonly rolling_std_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+    ddof: number,
+  ) => Float64Array;
+
+  /** Rolling median. */
+  readonly rolling_median_f64: (
+    data: Float64Array,
+    window: number,
+    min_periods: number,
+  ) => Float64Array;
+
+  // ── expanding window functions ────────────────────────────────────────────
+
+  /** Expanding sum. */
+  readonly expanding_sum_f64: (data: Float64Array, min_periods: number) => Float64Array;
+
+  /** Expanding mean. */
+  readonly expanding_mean_f64: (data: Float64Array, min_periods: number) => Float64Array;
+
+  /** Expanding minimum. */
+  readonly expanding_min_f64: (data: Float64Array, min_periods: number) => Float64Array;
+
+  /** Expanding maximum. */
+  readonly expanding_max_f64: (data: Float64Array, min_periods: number) => Float64Array;
+
+  /** Expanding variance with delta degrees-of-freedom `ddof`. */
+  readonly expanding_var_f64: (
+    data: Float64Array,
+    min_periods: number,
+    ddof: number,
+  ) => Float64Array;
+
+  /** Expanding standard deviation with delta degrees-of-freedom `ddof`. */
+  readonly expanding_std_f64: (
+    data: Float64Array,
+    min_periods: number,
+    ddof: number,
+  ) => Float64Array;
+
+  /** Expanding median. */
+  readonly expanding_median_f64: (data: Float64Array, min_periods: number) => Float64Array;
+
   // ── natsort ─────────────────────────────────────────────────────────────────
 
   /**
diff --git a/tests/wasm/parity.test.ts b/tests/wasm/parity.test.ts
index 3d99f722..47dd5d05 100644
--- a/tests/wasm/parity.test.ts
+++ b/tests/wasm/parity.test.ts
@@ -368,3 +368,281 @@ describe("nat_argsort parity", () => {
     expect(wasmIdx).toEqual(tsIdx);
   });
 });
+
+// ─── scalar reductions ────────────────────────────────────────────────────────
+
+describe("sum_f64 parity", () => {
+  test("basic sum", () => {
+    if (wasm === null) {
+      skip("basic sum");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+    expect(wasm.sum_f64(arr)).toBe(15.0);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    const arr = new Float64Array([1.0, Number.NaN, 3.0]);
+    expect(wasm.sum_f64(arr)).toBe(4.0);
+  });
+
+  test("empty array returns 0", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.sum_f64(new Float64Array([]))).toBe(0.0);
+  });
+
+  test("all-NaN returns 0", () => {
+    if (wasm === null) {
+      skip("all-NaN");
+      return;
+    }
+    expect(wasm.sum_f64(new Float64Array([Number.NaN, Number.NaN]))).toBe(0.0);
+  });
+});
+
+describe("mean_f64 parity", () => {
+  test("basic mean", () => {
+    if (wasm === null) {
+      skip("basic mean");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+    expect(wasm.mean_f64(arr)).toBeCloseTo(3.0, 10);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    const arr = new Float64Array([1.0, Number.NaN, 5.0]);
+    expect(wasm.mean_f64(arr)).toBeCloseTo(3.0, 10);
+  });
+
+  test("empty array returns NaN", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.mean_f64(new Float64Array([]))).toBeNaN();
+  });
+});
+
+describe("min_f64 parity", () => {
+  test("basic min", () => {
+    if (wasm === null) {
+      skip("basic min");
+      return;
+    }
+    const arr = new Float64Array([3.0, 1.0, 4.0, 1.5]);
+    expect(wasm.min_f64(arr)).toBe(1.0);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    expect(wasm.min_f64(new Float64Array([Number.NaN, 2.0, 1.0]))).toBe(1.0);
+  });
+
+  test("empty array returns NaN", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.min_f64(new Float64Array([]))).toBeNaN();
+  });
+});
+
+describe("max_f64 parity", () => {
+  test("basic max", () => {
+    if (wasm === null) {
+      skip("basic max");
+      return;
+    }
+    const arr = new Float64Array([3.0, 1.0, 4.0, 1.5]);
+    expect(wasm.max_f64(arr)).toBe(4.0);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    expect(wasm.max_f64(new Float64Array([Number.NaN, 2.0, 5.0]))).toBe(5.0);
+  });
+
+  test("empty array returns NaN", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.max_f64(new Float64Array([]))).toBeNaN();
+  });
+});
+
+describe("var_f64 parity", () => {
+  test("known variance (ddof=1)", () => {
+    if (wasm === null) {
+      skip("known variance");
+      return;
+    }
+    // Variance of [2, 4, 4, 4, 5, 5, 7, 9] = 4.571...
+    const arr = new Float64Array([2, 4, 4, 4, 5, 5, 7, 9]);
+    expect(wasm.var_f64(arr, 1)).toBeCloseTo(4.5714, 3);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    const arr = new Float64Array([2.0, Number.NaN, 4.0]);
+    expect(wasm.var_f64(arr, 1)).toBeCloseTo(2.0, 10);
+  });
+
+  test("single element returns NaN (ddof=1 makes n-1=0)", () => {
+    if (wasm === null) {
+      skip("single element");
+      return;
+    }
+    expect(wasm.var_f64(new Float64Array([5.0]), 1)).toBeNaN();
+  });
+});
+
+describe("std_f64 parity", () => {
+  test("basic std (ddof=1)", () => {
+    if (wasm === null) {
+      skip("basic std");
+      return;
+    }
+    const arr = new Float64Array([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]);
+    expect(wasm.std_f64(arr, 1)).toBeCloseTo(Math.sqrt(4.5714), 3);
+  });
+
+  test("empty returns NaN", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.std_f64(new Float64Array([]), 1)).toBeNaN();
+  });
+});
+
+describe("median_f64 parity", () => {
+  test("odd count median", () => {
+    if (wasm === null) {
+      skip("odd count");
+      return;
+    }
+    expect(wasm.median_f64(new Float64Array([3.0, 1.0, 2.0]))).toBe(2.0);
+  });
+
+  test("even count median is average of two middle", () => {
+    if (wasm === null) {
+      skip("even count");
+      return;
+    }
+    expect(wasm.median_f64(new Float64Array([1.0, 2.0, 3.0, 4.0]))).toBe(2.5);
+  });
+
+  test("NaN values are skipped", () => {
+    if (wasm === null) {
+      skip("NaN skipped");
+      return;
+    }
+    expect(wasm.median_f64(new Float64Array([1.0, Number.NaN, 3.0]))).toBe(2.0);
+  });
+
+  test("empty returns NaN", () => {
+    if (wasm === null) {
+      skip("empty");
+      return;
+    }
+    expect(wasm.median_f64(new Float64Array([]))).toBeNaN();
+  });
+});
+
+// ─── rolling window reductions ────────────────────────────────────────────────
+
+describe("rolling_sum_f64 parity", () => {
+  test("basic rolling sum (window=3)", () => {
+    if (wasm === null) {
+      skip("rolling sum");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+    const result = Array.from(wasm.rolling_sum_f64(arr, 3, 3));
+    expect(result[0]).toBeNaN();
+    expect(result[1]).toBeNaN();
+    expect(result[2]).toBeCloseTo(6.0, 10);
+    expect(result[3]).toBeCloseTo(9.0, 10);
+    expect(result[4]).toBeCloseTo(12.0, 10);
+  });
+
+  test("min_periods=1 produces earlier results", () => {
+    if (wasm === null) {
+      skip("min_periods=1");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0]);
+    const result = Array.from(wasm.rolling_sum_f64(arr, 3, 1));
+    expect(result[0]).toBeCloseTo(1.0, 10);
+    expect(result[1]).toBeCloseTo(3.0, 10);
+    expect(result[2]).toBeCloseTo(6.0, 10);
+  });
+});
+
+describe("rolling_mean_f64 parity", () => {
+  test("basic rolling mean (window=3)", () => {
+    if (wasm === null) {
+      skip("rolling mean");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+    const result = Array.from(wasm.rolling_mean_f64(arr, 3, 3));
+    expect(Number.isNaN(result[0])).toBe(true);
+    expect(Number.isNaN(result[1])).toBe(true);
+    expect(result[2]).toBeCloseTo(2.0, 10);
+    expect(result[3]).toBeCloseTo(3.0, 10);
+    expect(result[4]).toBeCloseTo(4.0, 10);
+  });
+});
+
+// ─── expanding window reductions ──────────────────────────────────────────────
+
+describe("expanding_mean_f64 parity", () => {
+  test("cumulative mean grows correctly", () => {
+    if (wasm === null) {
+      skip("expanding mean");
+      return;
+    }
+    const arr = new Float64Array([1.0, 3.0, 5.0]);
+    const result = Array.from(wasm.expanding_mean_f64(arr, 1));
+    expect(result[0]).toBeCloseTo(1.0, 10);
+    expect(result[1]).toBeCloseTo(2.0, 10);
+    expect(result[2]).toBeCloseTo(3.0, 10);
+  });
+});
+
+describe("expanding_sum_f64 parity", () => {
+  test("cumulative sum", () => {
+    if (wasm === null) {
+      skip("expanding sum");
+      return;
+    }
+    const arr = new Float64Array([1.0, 2.0, 3.0]);
+    const result = Array.from(wasm.expanding_sum_f64(arr, 1));
+    expect(result[0]).toBeCloseTo(1.0, 10);
+    expect(result[1]).toBeCloseTo(3.0, 10);
+    expect(result[2]).toBeCloseTo(6.0, 10);
+  });
+});
diff --git a/wasm-coverage.json b/wasm-coverage.json
index c96b3617..1b5e8bf9 100644
--- a/wasm-coverage.json
+++ b/wasm-coverage.json
@@ -1,7 +1,13 @@
 {
   "version": "1",
   "description": "Rust/WASM acceleration coverage manifest for tsb core functions",
-  "notes": "Every value export from src/core/index.ts is classified as either rust-wasm (implemented in Rust, exported through WASM, wired into the accelerated path) or ts-only-ineligible (not suitable for Rust/WASM with a concrete reason). There are no unclassified or todo entries.",
+  "summary": {
+    "total_core_entries": 143,
+    "rust_wasm": 6,
+    "ts_only_ineligible": 137,
+    "unclassified": 0,
+    "eligible_missing": 0
+  },
   "entries": [
     {
       "name": "natCompare",
@@ -32,7 +38,7 @@
       "name": "natSortKey",
       "module": "core/natsort",
       "status": "ts-only-ineligible",
-      "reason": "Return type is readonly (string|number)[] — a JS-specific union array that has no direct WASM representation without per-element boxing. The resulting round-trip cost would likely exceed any benefit."
+      "reason": "Return type is readonly (string|number)[] \u2014 a JS-specific union array that has no direct WASM representation without per-element boxing. The resulting round-trip cost would likely exceed any benefit."
     },
     {
       "name": "searchsorted",
@@ -65,7 +71,234 @@
       "name": "Index",
       "module": "core/base-index",
       "status": "ts-only-ineligible",
-      "reason": "Complex JS class with JS-specific semantics: symbol-keyed properties, JS object identity, generator methods, and deep integration with the JS iterator protocol. All label-lookup logic depends on JS Map/Set identity."
+      "reason": "Complex JS class with JS-specific semantics: symbol-keyed properties, JS object identity, generator methods, and deep integration with the JS iterator protocol. All label-lookup logic depends on JS Map/Set identity.",
+      "methods": [
+        {
+          "name": "append",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new Index instance with a TypeScript Index; result construction and label preservation require JS runtime class instantiation."
+        },
+        {
+          "name": "argmax",
+          "status": "ts-only-ineligible",
+          "reason": "Finds the integer position of the maximum label using JS comparison semantics for string/number/boolean Index labels."
+        },
+        {
+          "name": "argmin",
+          "status": "ts-only-ineligible",
+          "reason": "Finds the integer position of the minimum label using JS comparison semantics for string/number/boolean Index labels."
+        },
+        {
+          "name": "argsort",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a permutation array that sorts the Index labels; uses JS string/number comparison semantics for mixed-type labels."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the label at a given integer position; pure TypeScript property access with no numeric computation."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Checks label membership using JS equality via the Index._map lookup structure; no numeric computation."
+        },
+        {
+          "name": "copy",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "delete",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "difference",
+          "status": "ts-only-ineligible",
+          "reason": "Returns labels in this Index not present in another, using JS equality semantics for label comparison and a Set for deduplication."
+        },
+        {
+          "name": "drop",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dropDuplicates",
+          "status": "ts-only-ineligible",
+          "reason": "Removes duplicate labels using a JavaScript Set for deduplication with JS equality semantics; returns a new TypeScript Index."
+        },
+        {
+          "name": "dropna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "duplicated",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "equals",
+          "status": "ts-only-ineligible",
+          "reason": "Checks structural equality between two Index objects using JS element-wise === comparison; no numeric computation."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getIndexer",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getLoc",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hasDuplicates",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "identical",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "insert",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "intersection",
+          "status": "ts-only-ineligible",
+          "reason": "Returns labels present in both Index objects using JS Set intersection semantics; no numeric computation."
+        },
+        {
+          "name": "isMonotonicDecreasing",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isMonotonicIncreasing",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isUnique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isin",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "map",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the maximum label using JS comparison operators for string/number/boolean labels; no WASM-compatible numeric type."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the minimum label using JS comparison operators for string/number/boolean labels; no WASM-compatible numeric type."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nunique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new Index with a different name property; pure TypeScript metadata operation."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "slice",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a contiguous sub-range of labels as a new TypeScript Index; pure JS array slicing with Index construction."
+        },
+        {
+          "name": "sortValues",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "symmetricDifference",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "take",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises to a JavaScript object, array, or string using JS runtime formatting and object construction; no numeric computation suitable for WASM."
+        },
+        {
+          "name": "toList",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises to a JavaScript object, array, or string using JS runtime formatting and object construction; no numeric computation suitable for WASM."
+        },
+        {
+          "name": "union",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the union of labels from two Index objects using JS Set union semantics; no numeric computation."
+        },
+        {
+          "name": "values",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Index TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "RangeIndex",
@@ -77,103 +310,1967 @@
       "name": "Dtype",
       "module": "core/dtype",
       "status": "ts-only-ineligible",
-      "reason": "JS class whose instances are used as JS runtime type tokens. Equality is checked via JS object identity. Cannot be serialised to/from WASM without losing identity semantics."
+      "reason": "JS class whose instances are used as JS runtime type tokens. Equality is checked via JS object identity. Cannot be serialised to/from WASM without losing identity semantics.",
+      "methods": [
+        {
+          "name": "canCastTo",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "equals",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isBool",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isCategory",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isDatetime",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isFloat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isInteger",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isNumeric",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isObject",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isSignedInteger",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isTimedelta",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isUnsignedInteger",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Dtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Series",
       "module": "core/series",
       "status": "ts-only-ineligible",
-      "reason": "High-level JS class whose methods accept arbitrary JS callbacks, return new Series instances, and interoperate with JS accessors, Index objects, and the extension registry. Porting at the class level would require replacing the entire TS implementation."
+      "reason": "High-level JS class whose methods accept arbitrary JS callbacks, return new Series instances, and interoperate with JS accessors, Index objects, and the extension registry. Porting at the class level would require replacing the entire TS implementation.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise numeric addition with optional index alignment when the operand is a Series, requiring JS label-based alignment, dtype promotion, and NA propagation through JavaScript missing-value identity semantics."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Label-based element access; traverses the TypeScript Index using JS equality semantics to locate the label, then returns the stored JS value."
+        },
+        {
+          "name": "cat",
+          "status": "ts-only-ineligible",
+          "reason": "Accessor property returning a CategoricalAccessor JS object that maintains a live reference to the parent Series instance."
+        },
+        {
+          "name": "copy",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a deep copy of the Series by constructing a new TypeScript Series instance with cloned data array and Index; no numeric computation."
+        },
+        {
+          "name": "corr",
+          "status": "ts-only-ineligible",
+          "reason": "Computes Pearson correlation requiring index alignment between two Series objects, JS label-based pairing for matched values, and NA-aware accumulation over aligned pairs."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Counts non-null values by filtering through JavaScript null/undefined/NaN identity checks; result is a scalar with no heavy numeric computation."
+        },
+        {
+          "name": "div",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise true division with optional index alignment when the operand is a Series, requiring JS label-based alignment, dtype promotion, and NA propagation through JavaScript missing-value identity semantics."
+        },
+        {
+          "name": "dropna",
+          "status": "ts-only-ineligible",
+          "reason": "Removes null/undefined/NaN entries and returns a new Series with a filtered TypeScript Index preserving original labels."
+        },
+        {
+          "name": "dt",
+          "status": "ts-only-ineligible",
+          "reason": "Accessor property returning a DatetimeAccessor JS object that maintains a live reference to the parent Series instance."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "eq",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise equality comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison that returns null for missing pairs."
+        },
+        {
+          "name": "ewm",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method that constructs a TypeScript EWM (exponentially-weighted moving) object; EWM requires per-element recursive alpha weighting tied to JS runtime state."
+        },
+        {
+          "name": "expanding",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method that constructs and returns a TypeScript Expanding window object; no computation is performed until an aggregation method is called."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Replaces missing values (null/undefined/NaN) per JS identity semantics; returns a new Series with TypeScript Index and same labels."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Filters rows by a boolean Series or boolean array; returns a new Series with a filtered TypeScript Index preserving original labels."
+        },
+        {
+          "name": "flags",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter that constructs and returns a TypeScript Flags object wrapping the Series metadata; no array computation."
+        },
+        {
+          "name": "floordiv",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise floor division with JS label-based index alignment when the operand is a Series; dtype promotion and NA propagation require JavaScript runtime semantics."
+        },
+        {
+          "name": "ge",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise greater-than-or-equal comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison with null propagation."
+        },
+        {
+          "name": "groupby",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method constructing a TypeScript SeriesGroupBy object using a JavaScript Map for group key aggregation; group semantics require JS label identity."
+        },
+        {
+          "name": "gt",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise greater-than comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison with null propagation."
+        },
+        {
+          "name": "iat",
+          "status": "ts-only-ineligible",
+          "reason": "Integer-position element access; returns the raw JS stored value at index i without any numeric computation."
+        },
+        {
+          "name": "iloc",
+          "status": "ts-only-ineligible",
+          "reason": "Integer-position selection returning a scalar or new Series with TypeScript Index slice and JS array slicing semantics."
+        },
+        {
+          "name": "isin",
+          "status": "ts-only-ineligible",
+          "reason": "Checks membership using a JavaScript Set or array with JS triple-equals equality semantics for mixed-type scalar values."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Checks each element for null/undefined/NaN using JavaScript identity operators; returns a new Series<boolean> with TypeScript Index construction."
+        },
+        {
+          "name": "le",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise less-than-or-equal comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison with null propagation."
+        },
+        {
+          "name": "length",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "loc",
+          "status": "ts-only-ineligible",
+          "reason": "Label-based selection returning a scalar or new Series with TypeScript Index construction and JS label matching semantics."
+        },
+        {
+          "name": "lt",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise less-than comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison that returns null for missing pairs."
+        },
+        {
+          "name": "map",
+          "status": "ts-only-ineligible",
+          "reason": "Applies a JavaScript Map object or function to each element; arbitrary JS callback or Map lookup cannot cross the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "rust-wasm",
+          "wasm_function": "max_f64"
+        },
+        {
+          "name": "mean",
+          "status": "rust-wasm",
+          "wasm_function": "mean_f64"
+        },
+        {
+          "name": "median",
+          "status": "rust-wasm",
+          "wasm_function": "median_f64"
+        },
+        {
+          "name": "min",
+          "status": "rust-wasm",
+          "wasm_function": "min_f64"
+        },
+        {
+          "name": "mod",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise modulo with JS label-based index alignment when the operand is a Series; dtype promotion and NA propagation require JavaScript runtime semantics."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise multiplication with optional index alignment when the operand is a Series, requiring JS label-based alignment, dtype promotion, and NA propagation through JavaScript missing-value identity semantics."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "ne",
+          "status": "ts-only-ineligible",
+          "reason": "Element-wise inequality comparison returning Series<boolean>; requires JS label-based index alignment and NA-aware comparison that returns null for missing pairs."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Checks each element for non-missing using JavaScript identity operators; returns a new Series<boolean> with TypeScript Index construction."
+        },
+        {
+          "name": "nunique",
+          "status": "ts-only-ineligible",
+          "reason": "Counts distinct non-null values using a JavaScript Set for deduplication with JS equality semantics; no heavy numeric computation."
+        },
+        {
+          "name": "pow",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise exponentiation with JS label-based index alignment when the operand is a Series; dtype promotion and NA propagation require JavaScript runtime semantics."
+        },
+        {
+          "name": "quantile",
+          "status": "ts-only-ineligible",
+          "reason": "Computes a quantile via linear interpolation on sorted non-null values using a float position index; semantics differ from median and require a separate Rust function not yet implemented."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new Series with a different name metadata property; pure TypeScript metadata operation with no array computation."
+        },
+        {
+          "name": "resetIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new Series with a default RangeIndex, constructing new TypeScript RangeIndex and Series instances."
+        },
+        {
+          "name": "rolling",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method that constructs and returns a TypeScript Rolling window object; no computation is performed until an aggregation method is called."
+        },
+        {
+          "name": "setIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Replaces the Series index with a provided Index object; requires TypeScript Index validation and Series re-construction."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "sortIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Sorts Series by its Index labels using JS label comparison with NA handling; constructs new TypeScript Index and Series from sorted permutation."
+        },
+        {
+          "name": "sortValues",
+          "status": "rust-wasm",
+          "wasm_function": "argsort_f64"
+        },
+        {
+          "name": "std",
+          "status": "rust-wasm",
+          "wasm_function": "std_f64"
+        },
+        {
+          "name": "str",
+          "status": "ts-only-ineligible",
+          "reason": "Accessor property returning a StringAccessor JS object that maintains a live reference to the parent Series instance."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Performs element-wise numeric subtraction with optional index alignment when the operand is a Series, requiring JS label-based alignment, dtype promotion, and NA propagation through JavaScript missing-value identity semantics."
+        },
+        {
+          "name": "sum",
+          "status": "rust-wasm",
+          "wasm_function": "sum_f64"
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a JavaScript Array copy of the data values; pure JS object construction with no numeric computation."
+        },
+        {
+          "name": "toList",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a JavaScript Array copy of the data values; pure JS object construction with no numeric computation."
+        },
+        {
+          "name": "toObject",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises the Series to a plain JS object using index labels as keys; requires JS object construction and string coercion."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Formats the Series as a human-readable string using JS string interpolation and column-width alignment; no numeric computation."
+        },
+        {
+          "name": "unique",
+          "status": "ts-only-ineligible",
+          "reason": "Returns an array of distinct values using JavaScript Set deduplication; preserves JS equality semantics for mixed types."
+        },
+        {
+          "name": "valueCounts",
+          "status": "ts-only-ineligible",
+          "reason": "Builds a frequency map using a JavaScript Map, then constructs a sorted result Series with TypeScript Index; requires JS object semantics."
+        },
+        {
+          "name": "values",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning the frozen JS array of raw data values; returns a reference to the internal TypeScript storage."
+        },
+        {
+          "name": "var",
+          "status": "rust-wasm",
+          "wasm_function": "var_f64"
+        },
+        {
+          "name": "withValues",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new Series with a different data array while preserving Index and metadata; pure TypeScript reconstruction with no numeric computation."
+        }
+      ]
     },
     {
       "name": "DataFrame",
       "module": "core/frame",
       "status": "ts-only-ineligible",
-      "reason": "Same as Series: high-level JS class with arbitrary JS callbacks, JS accessors, rolling/expanding/ewm subclasses, and deep interoperation with Series and Index."
+      "reason": "High-level JS class with per-column label dispatch, method-chaining accessors, rolling/expanding/ewm subclasses, and deep interoperation with Series and TypeScript Index objects. Porting the class itself to WASM would require replacing the entire TypeScript implementation.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Accepts an arbitrary JavaScript callback function as a parameter. JS functions cannot cross the WASM/JS boundary; the computation must stay in TypeScript."
+        },
+        {
+          "name": "assign",
+          "status": "ts-only-ineligible",
+          "reason": "Adds or replaces columns using a specification that can include JS callback functions or static values; requires JS object semantics for column label management."
+        },
+        {
+          "name": "col",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a single column as a TypeScript Series with its Index preserved; column lookup uses JS label identity on the column Index."
+        },
+        {
+          "name": "corr",
+          "status": "ts-only-ineligible",
+          "reason": "Computes pairwise Pearson correlation over numeric columns; requires per-pair NA-aware accumulation, JS column label selection, dtype filtering for non-numeric columns, and result assembly into a new DataFrame."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Counts non-null values per column using JavaScript identity checks; returns a Series with column labels as Index."
+        },
+        {
+          "name": "cov",
+          "status": "ts-only-ineligible",
+          "reason": "Computes pairwise sample covariance over numeric columns; requires per-pair NA-aware accumulation, JS column label selection, dtype filtering, and result assembly into a new DataFrame."
+        },
+        {
+          "name": "describe",
+          "status": "ts-only-ineligible",
+          "reason": "Computes descriptive statistics (count, mean, std, min, max) per column; returns a DataFrame with stat-name rows, requiring JS label construction."
+        },
+        {
+          "name": "drop",
+          "status": "ts-only-ineligible",
+          "reason": "Drops rows or columns by label using JS label identity; returns a new DataFrame with filtered TypeScript column and row Index objects."
+        },
+        {
+          "name": "dropna",
+          "status": "ts-only-ineligible",
+          "reason": "Drops rows or columns containing null/undefined/NaN using JS identity checks; returns a new DataFrame with filtered TypeScript Index objects."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "ewm",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method constructing a TypeScript DataFrameEwm object; EWM requires per-element recursive alpha weighting tied to JS runtime state."
+        },
+        {
+          "name": "expanding",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method constructing a TypeScript DataFrameExpanding object that wraps the DataFrame for expanding-window aggregations."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Replaces missing values per column using JS identity checks; returns a new DataFrame with TypeScript Index and metadata preserved."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Selects rows by a boolean mask Series or array; returns a new DataFrame with filtered TypeScript row Index."
+        },
+        {
+          "name": "flags",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning a TypeScript Flags object wrapping DataFrame metadata; no numeric computation."
+        },
+        {
+          "name": "get",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a column as a TypeScript Series or scalar by JS label identity; requires column Index lookup."
+        },
+        {
+          "name": "groupby",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method constructing a TypeScript DataFrameGroupBy object using JavaScript Map-based group key aggregation."
+        },
+        {
+          "name": "has",
+          "status": "ts-only-ineligible",
+          "reason": "Checks whether a column label exists using JS label identity on the column Index; returns a boolean scalar."
+        },
+        {
+          "name": "head",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the first N rows as a new DataFrame; pure TypeScript slice with Index and column Index construction."
+        },
+        {
+          "name": "iloc",
+          "status": "ts-only-ineligible",
+          "reason": "Integer-position row/column selection returning a new DataFrame or scalar; requires TypeScript Index slicing and JS array operations."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Checks each element for null/undefined/NaN using JS identity operators; returns a new boolean DataFrame with TypeScript Index."
+        },
+        {
+          "name": "loc",
+          "status": "ts-only-ineligible",
+          "reason": "Label-based row/column selection returning a new DataFrame or scalar; requires TypeScript Index lookup with JS label identity."
+        },
+        {
+          "name": "max",
+          "status": "rust-wasm",
+          "wasm_function": "max_f64"
+        },
+        {
+          "name": "mean",
+          "status": "rust-wasm",
+          "wasm_function": "mean_f64"
+        },
+        {
+          "name": "min",
+          "status": "rust-wasm",
+          "wasm_function": "min_f64"
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Checks each element for non-missing using JS identity operators; returns a new boolean DataFrame with TypeScript Index."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new DataFrame with renamed row or column labels; pure TypeScript Index construction with no numeric computation."
+        },
+        {
+          "name": "resetIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new DataFrame with a default RangeIndex; pure TypeScript Index reconstruction."
+        },
+        {
+          "name": "rolling",
+          "status": "ts-only-ineligible",
+          "reason": "Factory method constructing a TypeScript DataFrameRolling object that wraps the DataFrame for sliding-window aggregations."
+        },
+        {
+          "name": "select",
+          "status": "ts-only-ineligible",
+          "reason": "Returns a new DataFrame with a subset of columns by label; requires TypeScript column Index construction and JS label identity."
+        },
+        {
+          "name": "setIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Promotes a column to the row Index and returns a new DataFrame; requires TypeScript Index construction and column removal."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Property getter returning scalar metadata (size, shape, ndim, empty, flags, or similar) from the TypeScript instance; no array computation is involved."
+        },
+        {
+          "name": "sortIndex",
+          "status": "ts-only-ineligible",
+          "reason": "Sorts DataFrame rows by their Index labels using JS label comparison; constructs new TypeScript Index and DataFrame."
+        },
+        {
+          "name": "sortValues",
+          "status": "rust-wasm",
+          "wasm_function": "argsort_f64"
+        },
+        {
+          "name": "std",
+          "status": "rust-wasm",
+          "wasm_function": "std_f64"
+        },
+        {
+          "name": "sum",
+          "status": "rust-wasm",
+          "wasm_function": "sum_f64"
+        },
+        {
+          "name": "tail",
+          "status": "ts-only-ineligible",
+          "reason": "Returns the last N rows as a new DataFrame; pure TypeScript slice with Index construction."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises to a JavaScript object, array, or string using JS runtime formatting and object construction; no numeric computation suitable for WASM."
+        },
+        {
+          "name": "toDict",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises to a JavaScript object, array, or string using JS runtime formatting and object construction; no numeric computation suitable for WASM."
+        },
+        {
+          "name": "toRecords",
+          "status": "ts-only-ineligible",
+          "reason": "Serialises to a JavaScript object, array, or string using JS runtime formatting and object construction; no numeric computation suitable for WASM."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Formats the DataFrame as a human-readable table using JS string interpolation; no numeric computation."
+        }
+      ]
     },
     {
       "name": "DataFrameRolling",
       "module": "core/frame",
       "status": "ts-only-ineligible",
-      "reason": "Inner class of DataFrame; window computation returns new DataFrame/Series instances and accepts JS callbacks."
+      "reason": "Inner class of DataFrame; window computation returns new DataFrame/Series instances and accepts JS callbacks.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Accepts an arbitrary JavaScript callback function as a parameter. JS functions cannot cross the WASM/JS boundary; the computation must stay in TypeScript."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Counts non-NaN values per window position per column; returns result as a DataFrame with TypeScript Index. Count has O(1) per-window skip semantics that bypass min_periods, requiring TypeScript control flow."
+        },
+        {
+          "name": "max",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_max_f64"
+        },
+        {
+          "name": "mean",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_mean_f64"
+        },
+        {
+          "name": "median",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_median_f64"
+        },
+        {
+          "name": "min",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_min_f64"
+        },
+        {
+          "name": "std",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_std_f64"
+        },
+        {
+          "name": "sum",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_sum_f64"
+        },
+        {
+          "name": "var",
+          "status": "rust-wasm",
+          "wasm_function": "rolling_var_f64"
+        }
+      ]
     },
     {
       "name": "DataFrameExpanding",
       "module": "core/frame",
       "status": "ts-only-ineligible",
-      "reason": "Inner class of DataFrame; same reasoning as DataFrameRolling."
+      "reason": "Inner class of DataFrame; same reasoning as DataFrameRolling.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Accepts an arbitrary JavaScript callback function as a parameter. JS functions cannot cross the WASM/JS boundary; the computation must stay in TypeScript."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Counts non-NaN values per window position per column; returns result as a DataFrame with TypeScript Index. Count has O(1) per-window skip semantics that bypass min_periods, requiring TypeScript control flow."
+        },
+        {
+          "name": "max",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_max_f64"
+        },
+        {
+          "name": "mean",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_mean_f64"
+        },
+        {
+          "name": "median",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_median_f64"
+        },
+        {
+          "name": "min",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_min_f64"
+        },
+        {
+          "name": "std",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_std_f64"
+        },
+        {
+          "name": "sum",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_sum_f64"
+        },
+        {
+          "name": "var",
+          "status": "rust-wasm",
+          "wasm_function": "expanding_var_f64"
+        }
+      ]
     },
     {
       "name": "DataFrameEwm",
       "module": "core/frame",
       "status": "ts-only-ineligible",
-      "reason": "Inner class of DataFrame; exponentially weighted window — depends on JS class state and returns DataFrame/Series."
+      "reason": "Inner class of DataFrame; exponentially weighted window \u2014 depends on JS class state and returns DataFrame/Series.",
+      "methods": [
+        {
+          "name": "mean",
+          "status": "ts-only-ineligible",
+          "reason": "EWM mean uses per-element recursive alpha weighting where each value depends on the previous output value; the recursive state variable must persist in JS memory across iterations."
+        },
+        {
+          "name": "std",
+          "status": "ts-only-ineligible",
+          "reason": "EWM standard deviation uses per-element recursive alpha weighting with a running variance estimate; the recursive state variable must persist in JS memory across iterations."
+        },
+        {
+          "name": "var",
+          "status": "ts-only-ineligible",
+          "reason": "EWM variance uses per-element recursive alpha weighting with a running variance estimate; the recursive state variable must persist in JS memory across iterations."
+        }
+      ]
     },
     {
       "name": "StringAccessor",
       "module": "core/string_accessor",
       "status": "ts-only-ineligible",
-      "reason": "JS accessor class exposing string operations that use JS regex and Intl APIs internally. Many operations have no WASM equivalent without reimplementing the JS Unicode/Intl stack."
+      "reason": "JS accessor class exposing string operations that use JS regex and Intl APIs internally. Many operations have no WASM equivalent without reimplementing the JS Unicode/Intl stack.",
+      "methods": [
+        {
+          "name": "capitalize",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "cat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "center",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "encode",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "endswith",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "extract",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "find",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fullmatch",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "get",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isalnum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isalpha",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isdigit",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "islower",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isnumeric",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isspace",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "istitle",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isupper",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "join",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "len",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ljust",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lower",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lstrip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "match",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "pad",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "repeat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "replace",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rfind",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rjust",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rsplit",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rstrip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "slice",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sliceReplace",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "split",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "startswith",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "strip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "swapcase",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "title",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "upper",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "wrap",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "zfill",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "DatetimeAccessor",
       "module": "core/datetime_accessor",
       "status": "ts-only-ineligible",
-      "reason": "Wraps JS Date arithmetic and timezone conversions. Correctness depends on the JS Temporal/Intl system which cannot be reproduced from WASM without calling back into JS."
+      "reason": "Wraps JS Date arithmetic and timezone conversions. Correctness depends on the JS Temporal/Intl system which cannot be reproduced from WASM without calling back into JS.",
+      "methods": [
+        {
+          "name": "ceil",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "date",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "day",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofweek",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofyear",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "days_in_month",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "daysinmonth",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "floor",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hour",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_leap_year",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_month_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_month_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_quarter_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_quarter_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_year_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_year_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isocalendar_week",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "microsecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "millisecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "minute",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "month",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nanosecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "normalize",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "quarter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "round",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "second",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "strftime",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "total_seconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "weekday",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "year",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "CategoricalAccessor",
       "module": "core/cat_accessor",
       "status": "ts-only-ineligible",
-      "reason": "JS accessor that manages a categorical code/categories array pair stored as JS arrays with JS object identity. No isolated numeric kernel."
+      "reason": "JS accessor that manages a categorical code/categories array pair stored as JS arrays with JS object identity. No isolated numeric kernel.",
+      "methods": [
+        {
+          "name": "addCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "asOrdered",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "asUnordered",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "categories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "codes",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ordered",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "removeCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "removeUnusedCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "renameCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "reorderCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "setCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "valueCounts",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalAccessor TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "MultiIndex",
       "module": "core/multi_index",
       "status": "ts-only-ineligible",
-      "reason": "JS class holding multiple JS Index objects; label lookup uses JS Map with tuple keys represented as strings. Deep JS-identity dependency."
+      "reason": "JS class holding multiple JS Index objects; label lookup uses JS Map with tuple keys represented as strings. Deep JS-identity dependency.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "difference",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dropDuplicates",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "droplevel",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dropna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "duplicated",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "equals",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getLoc",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hasDuplicates",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "intersection",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isUnique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isin",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nlevels",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "reorderLevels",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "setNames",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sortValues",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "swaplevel",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toList",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "union",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MultiIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Interval",
       "module": "core/interval",
       "status": "ts-only-ineligible",
-      "reason": "JS class whose endpoints can be arbitrary Scalar values (including JS Date and Timedelta instances). Cannot be serialised to WASM without losing JS object semantics."
+      "reason": "JS class whose endpoints can be arbitrary Scalar values (including JS Date and Timedelta instances). Cannot be serialised to WASM without losing JS object semantics.",
+      "methods": [
+        {
+          "name": "closedLeft",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "closedRight",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isEmpty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "length",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mid",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "overlaps",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Interval TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "IntervalIndex",
       "module": "core/interval",
       "status": "ts-only-ineligible",
-      "reason": "Inherits from Index; holds Interval instances. Same JS-identity constraint as Interval."
+      "reason": "Inherits from Index; holds Interval instances. Same JS-identity constraint as Interval.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "get_loc",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isMonotonic",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isMonotonicDecreasing",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isMonotonicIncreasing",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "length",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mid",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "overlaps",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntervalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "CategoricalIndex",
       "module": "core/categorical_index",
       "status": "ts-only-ineligible",
-      "reason": "JS class for categorical index labels; depends on JS Map/Set identity for deduplication."
+      "reason": "JS class for categorical index labels; depends on JS Map/Set identity for deduplication.",
+      "methods": [
+        {
+          "name": "addCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "asOrdered",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "asUnordered",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "categories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "codes",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "compareLabels",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getLoc",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getLocsAll",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hasCategory",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "intersectCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "removeCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "removeUnusedCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "renameCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "reorderCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "setCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "unionCategories",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the CategoricalIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Period",
       "module": "core/period",
       "status": "ts-only-ineligible",
-      "reason": "JS class wrapping a period value with frequency metadata. Arithmetic calls JS Date methods and the date-offset registry."
+      "reason": "JS class wrapping a period value with frequency metadata. Arithmetic calls JS Date methods and the date-offset registry.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "asfreq",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "compareTo",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "diff",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "durationMs",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "endTime",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "equals",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "startTime",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toJSON",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Period TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "PeriodIndex",
       "module": "core/period",
       "status": "ts-only-ineligible",
-      "reason": "Holds Period instances; inherits from Index. Same JS-identity dependency as Period."
+      "reason": "Holds Period instances; inherits from Index. Same JS-identity dependency as Period.",
+      "methods": [
+        {
+          "name": "asfreq",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "getLoc",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shift",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sort",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toDatetimeEnd",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toDatetimeStart",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "unique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PeriodIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Timedelta",
       "module": "core/timedelta",
       "status": "ts-only-ineligible",
-      "reason": "JS class wrapping a duration in milliseconds plus component accessors. Arithmetic depends on JS Date. No isolated WASM-friendly kernel."
+      "reason": "JS class wrapping a duration in milliseconds plus component accessors. Arithmetic depends on JS Date. No isolated WASM-friendly kernel.",
+      "methods": [
+        {
+          "name": "abs",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "absMs",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "compareTo",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "days",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "divBy",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "eq",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "equals",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "gt",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hours",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lt",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "milliseconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "minutes",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ms",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "scale",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "seconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sign",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "subtract",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toISOString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalDays",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalHours",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalMinutes",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalMs",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalSeconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timedelta TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "TimedeltaIndex",
       "module": "core/timedelta",
       "status": "ts-only-ineligible",
-      "reason": "Holds Timedelta instances; inherits from Index. Same JS dependency as Timedelta."
+      "reason": "Holds Timedelta instances; inherits from Index. Same JS dependency as Timedelta.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rename",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shift",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sort",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toStrings",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "unique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "timedelta_range",
@@ -185,73 +2282,522 @@
       "name": "Day",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; applies/rolls dates using JS Date. Cannot function independently of the JS date system."
+      "reason": "JS DateOffset subclass; applies/rolls dates using JS Date. Cannot function independently of the JS date system.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Day TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Hour",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as Day."
+      "reason": "JS DateOffset subclass; same reasoning as Day.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Hour TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Minute",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as Day."
+      "reason": "JS DateOffset subclass; same reasoning as Day.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Minute TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Second",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as Day."
+      "reason": "JS DateOffset subclass; same reasoning as Day.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Second TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Milli",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as Day."
+      "reason": "JS DateOffset subclass; same reasoning as Day.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Milli TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "Week",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as Day."
+      "reason": "JS DateOffset subclass; same reasoning as Day.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Week TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "MonthEnd",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; end-of-month rollforward requires JS Date.setFullYear/setMonth."
+      "reason": "JS DateOffset subclass; end-of-month rollforward requires JS Date.setFullYear/setMonth.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "MonthBegin",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as MonthEnd."
+      "reason": "JS DateOffset subclass; same reasoning as MonthEnd.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MonthBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "YearEnd",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as MonthEnd."
+      "reason": "JS DateOffset subclass; same reasoning as MonthEnd.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearEnd TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "YearBegin",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; same reasoning as MonthEnd."
+      "reason": "JS DateOffset subclass; same reasoning as MonthEnd.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the YearBegin TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "BusinessDay",
       "module": "core/date_offset",
       "status": "ts-only-ineligible",
-      "reason": "JS DateOffset subclass; business-day skipping requires day-of-week arithmetic via JS Date."
+      "reason": "JS DateOffset subclass; business-day skipping requires day-of-week arithmetic via JS Date.",
+      "methods": [
+        {
+          "name": "apply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "multiply",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "negate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "onOffset",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollback",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rollforward",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BusinessDay TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "DatetimeIndex",
       "module": "core/date_range",
       "status": "ts-only-ineligible",
-      "reason": "Holds JS Date timestamps; inherits from Index. All construction and arithmetic uses JS Date APIs."
+      "reason": "Holds JS Date timestamps; inherits from Index. All construction and arithmetic uses JS Date APIs.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "concat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "normalize",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shift",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "slice",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "snap",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sort",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toStrings",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "unique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "values",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "date_range",
@@ -275,7 +2821,104 @@
       "name": "TZDatetimeIndex",
       "module": "core/datetime_tz",
       "status": "ts-only-ineligible",
-      "reason": "Holds timezone-aware JS Date values; localisation and conversion delegate entirely to the JS Intl.DateTimeFormat API."
+      "reason": "Holds timezone-aware JS Date values; localisation and conversion delegate entirely to the JS Intl.DateTimeFormat API.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "concat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "empty",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "filter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ndim",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "shape",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "slice",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sort",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toLocalStrings",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toTimestamps",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz_convert",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz_localize_none",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "unique",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "values",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TZDatetimeIndex TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "tz_localize",
@@ -293,7 +2936,254 @@
       "name": "Timestamp",
       "module": "core/timestamp",
       "status": "ts-only-ineligible",
-      "reason": "JS wrapper around a nanosecond-precision timestamp. Format and parse operations delegate to JS Intl and Date. Object identity used throughout tsb's datetime pipeline."
+      "reason": "JS wrapper around a nanosecond-precision timestamp. Format and parse operations delegate to JS Intl and Date. Object identity used throughout tsb's datetime pipeline.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ceil",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "date",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "day",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "day_name",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofweek",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofyear",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "eq",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "floor",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "freq",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ge",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "gt",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hour",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_leap_year",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_month_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_month_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_quarter_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_quarter_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_year_end",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "is_year_start",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isoformat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "le",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lt",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "microsecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "millisecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "minute",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "month",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "month_name",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "nanosecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "ne",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "normalize",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "quarter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "round",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "second",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "strftime",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "time",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "timestamp",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toDate",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toJSON",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz_convert",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz_localize",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tzinfo",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "valueOf",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "week",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "weekday",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "year",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Timestamp TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "dataFrameAssign",
@@ -461,7 +3351,7 @@
       "name": "seriesTransform",
       "module": "core/pipe_apply",
       "status": "ts-only-ineligible",
-      "reason": "Same as seriesApply; accepts a JS callback that must run in the JS context."
+      "reason": "Applies a TypeScript transformation callback to a Series, where the callback receives and returns Series instances; arbitrary JS function cannot cross the WASM/JS boundary."
     },
     {
       "name": "dataFrameApply",
@@ -695,13 +3585,52 @@
       "name": "ExtensionDtype",
       "module": "core/extensions",
       "status": "ts-only-ineligible",
-      "reason": "Abstract JS base class for the extension type system. Instances are registered in a runtime JS Map. No numeric kernel; purely a JS polymorphism mechanism."
+      "reason": "Abstract JS base class for the extension type system. Instances are registered in a runtime JS Map. No numeric kernel; purely a JS polymorphism mechanism.",
+      "methods": [
+        {
+          "name": "isNumeric",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionDtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "naMissingValue",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionDtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionDtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "ExtensionArray",
       "module": "core/extensions",
       "status": "ts-only-ineligible",
-      "reason": "Abstract JS base class for extension array types. Subclasses implement custom JS accessors. No WASM-accelerable kernel."
+      "reason": "Abstract JS base class for extension array types. Subclasses implement custom JS accessors. No WASM-accelerable kernel.",
+      "methods": [
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the ExtensionArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     },
     {
       "name": "registerExtensionDtype",
@@ -744,13 +3673,835 @@
       "module": "core/extensions",
       "status": "ts-only-ineligible",
       "reason": "Namespace object bundling the extension API; not a function, purely a JS namespace accessor."
+    },
+    {
+      "name": "Flags",
+      "module": "core/flags",
+      "status": "ts-only-ineligible",
+      "reason": "JS class whose instances are WeakMap-backed runtime objects that track read-only/copy-on-write metadata for DataFrame/Series. Behaviour is defined by JS object identity and WeakMap lifecycle; cannot be serialised to WASM without losing those semantics.",
+      "methods": [
+        {
+          "name": "allowsDuplicateLabels",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Flags TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "copy",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Flags TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "raiseOnDuplicates",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Flags TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the Flags TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "getFlags",
+      "module": "core/flags",
+      "status": "ts-only-ineligible",
+      "reason": "Retrieves a Flags instance from a WeakMap keyed on a live JS object reference. Depends entirely on JS object identity and garbage-collector lifecycle; not a numeric kernel."
+    },
+    {
+      "name": "MaskedArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Base nullable extension array class. Its API accepts JS callbacks, returns new class instances, and integrates with the extension registry and the JS dtype system. Class-level porting would require replacing the entire TS class hierarchy.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dropna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hasNa",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArrayFilled",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the MaskedArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "IntegerArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable integer extension array class extending MaskedArray. Same JS class-instance semantics as MaskedArray; no standalone pure numeric kernel separable from the class.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "astype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "floordiv",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mean",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mod",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "pow",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the IntegerArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "FloatingArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable floating-point extension array class extending MaskedArray. Same JS class-instance semantics as MaskedArray.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "astype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mean",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "pow",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "std",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "truediv",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the FloatingArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "BooleanArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable boolean extension array class extending MaskedArray. Same JS class-instance semantics as MaskedArray.",
+      "methods": [
+        {
+          "name": "all",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "and",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "any",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "not",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "or",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the BooleanArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "StringArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable string extension array class extending MaskedArray. String data is UTF-16 JS strings; per-element copying to WASM memory would dominate any potential throughput gain.",
+      "methods": [
+        {
+          "name": "cat",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "contains",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "count",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "endswith",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "len",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lower",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "lstrip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "replace",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "rstrip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "startswith",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "strip",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "upper",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "zfill",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the StringArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "DatetimeArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable datetime extension array class extending MaskedArray. Datetime arithmetic depends on JS Date and Timestamp objects with timezone handling; no pure numeric kernel separable from the class.",
+      "methods": [
+        {
+          "name": "asMs",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "day",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofweek",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dayofyear",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hour",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "millisecond",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "minute",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "month",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "quarter",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "second",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "tz",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "year",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the DatetimeArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "TimedeltaArray",
+      "module": "core/arrays",
+      "status": "ts-only-ineligible",
+      "reason": "Nullable timedelta extension array class extending MaskedArray. Duration arithmetic depends on JS Timedelta objects and the extension registry; no pure numeric kernel separable from the class.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "days",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "hours",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "isna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "milliseconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "minutes",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "notna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "seconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "size",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sub",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalDays",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalHours",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalMilliseconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "totalSeconds",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the TimedeltaArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "SparseArray",
+      "module": "core/sparse",
+      "status": "ts-only-ineligible",
+      "reason": "Sparse storage array class whose fill-value semantics and block pointer structure are JS-object-based. Internal coordinate/value arrays are nullable JS arrays; no WASM-representable numeric kernel independent of the class.",
+      "methods": [
+        {
+          "name": "add",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "density",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "dtype",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fill_value",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "fillna",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "length",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "max",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mean",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "min",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "mul",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "npoints",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "slice",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sp_index",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sp_values",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "std",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "sum",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toCoo",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toDense",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "withFillValue",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "SparseDtype",
+      "module": "core/sparse",
+      "status": "ts-only-ineligible",
+      "reason": "JS class used as a runtime type token for SparseArray. Instances are compared by JS object identity throughout the dtype system; cannot be serialised to/from WASM without losing identity semantics.",
+      "methods": [
+        {
+          "name": "name",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseDtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the SparseDtype TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
+    },
+    {
+      "name": "getOption",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Runtime options registry accessor. Returns a JS value (string, number, boolean, or arbitrary object) from a live in-memory JS Map. Not a numeric operation; no WASM kernel applicable."
+    },
+    {
+      "name": "setOption",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Runtime options registry mutator. Writes to a live in-memory JS Map with optional validation callbacks. Not a numeric operation; no WASM kernel applicable."
+    },
+    {
+      "name": "resetOption",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Runtime options registry reset. Restores a JS Map entry to its default value. Not a numeric operation."
+    },
+    {
+      "name": "describeOption",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Returns a human-readable description string for a registered option. Purely a JS string operation over an in-memory registry."
+    },
+    {
+      "name": "optionContext",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Returns an async Symbol-keyed context token for scoped option overrides using JS async generators. Depends on JS Symbol identity and async lifecycle; not a numeric operation."
+    },
+    {
+      "name": "registerOption",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "Registers a new option in the global JS Map with a default value and optional validator callback. Registry mutation is not a numeric operation."
+    },
+    {
+      "name": "options",
+      "module": "core/options",
+      "status": "ts-only-ineligible",
+      "reason": "A JS Proxy object that provides live read/write access to the options registry. A Proxy is a JS-only construct with no WASM equivalent."
+    },
+    {
+      "name": "api",
+      "module": "core/pd_api",
+      "status": "ts-only-ineligible",
+      "reason": "Namespace object exposing the pd.api surface (types, extensions, internals). It is a static JS object used for grouping sub-namespaces; not a numeric function."
+    },
+    {
+      "name": "apiTypes",
+      "module": "core/pd_api",
+      "status": "ts-only-ineligible",
+      "reason": "Namespace object bundling the pd.api.types type-guard utilities. It is a static JS object; not a numeric function."
+    },
+    {
+      "name": "pdArray",
+      "module": "core/pd_array",
+      "status": "ts-only-ineligible",
+      "reason": "Factory function that dispatches to the appropriate nullable extension array constructor based on a dtype argument. Dispatch logic depends on JS instanceof checks and the extension registry."
+    },
+    {
+      "name": "PandasArray",
+      "module": "core/pd_array",
+      "status": "ts-only-ineligible",
+      "reason": "JS class wrapping a plain JS array for ndarray-compatibility (pd.arrays.PandasArray). Its API is defined by JS array semantics and the extension array protocol; not a pure numeric kernel.",
+      "methods": [
+        {
+          "name": "at",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PandasArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toArray",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PandasArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        },
+        {
+          "name": "toString",
+          "status": "ts-only-ineligible",
+          "reason": "Method on the PandasArray TypeScript class that requires JavaScript object construction, label semantics, type dispatch, or string/Date operations that cannot be cleanly abstracted across the WASM/JS boundary."
+        }
+      ]
     }
-  ],
-  "summary": {
-    "total_core_entries": 121,
-    "rust_wasm": 6,
-    "ts_only_ineligible": 115,
-    "unclassified": 0,
-    "eligible_missing": 0
-  }
+  ]
 }