pond-ts 0.24.0 → 0.26.0

package/dist/column.js

@@ -76,33 +76,60 @@ Float64Column.prototype.minMax = function () {
     const n = this.length;
     if (n === 0)
         return undefined;
-    let i = 0;
-    let lo;
-    let hi;
-    if (!v) {
-        lo = values[0];
+    if (this.allFinite) {
+        // Provably finite (the chart axis hot path) → no per-element finite
+        // guard; the seeded comparison is unambiguous without NaN.
+        let i = 0;
+        let lo;
+        let hi;
+        if (!v) {
+            lo = values[0];
+            hi = lo;
+            for (i = 1; i < n; i += 1) {
+                const x = values[i];
+                lo = lo <= x ? lo : x;
+                hi = hi >= x ? hi : x;
+            }
+            return [lo, hi];
+        }
+        while (i < n && !v.isDefined(i))
+            i += 1;
+        if (i >= n)
+            return undefined;
+        lo = values[i];
         hi = lo;
-        for (i = 1; i < n; i += 1) {
+        for (i += 1; i < n; i += 1) {
+            if (!v.isDefined(i))
+                continue;
             const x = values[i];
             lo = lo <= x ? lo : x;
             hi = hi >= x ? hi : x;
         }
         return [lo, hi];
     }
-    while (i < n && !v.isDefined(i))
-        i += 1;
-    if (i >= n)
-        return undefined;
-    lo = values[i];
-    hi = lo;
-    for (i += 1; i < n; i += 1) {
-        if (!v.isDefined(i))
+    // Guarded: skip non-finite (and missing) cells, matching the reducer
+    // `min`/`max` (reducer non-finite policy — docs/notes/reducer-nan-policy.md).
+    // All-non-finite (or empty) → undefined.
+    let lo;
+    let hi;
+    for (let i = 0; i < n; i += 1) {
+        if (v && !v.isDefined(i))
             continue;
         const x = values[i];
-        lo = lo <= x ? lo : x;
-        hi = hi >= x ? hi : x;
+        if (!Number.isFinite(x))
+            continue;
+        if (lo === undefined) {
+            lo = x;
+            hi = x;
+        }
+        else {
+            if (x < lo)
+                lo = x;
+            if (x > hi)
+                hi = x;
+        }
     }
-    return [lo, hi];
+    return lo === undefined ? undefined : [lo, hi];
 };
 Float64Column.prototype.hasMissing = function () {
     if (!this.validity)
@@ -228,6 +255,44 @@ Float64Column.prototype.bin = function (bins, reducer) {
         // underlying buffer.
         const values = this._values;
         const validity = this.validity;
+        if (!this.allFinite) {
+            // Guarded path: skip non-finite values (reducer non-finite policy —
+            // docs/notes/reducer-nan-policy.md), matching `minMax()` / the reducer
+            // min/max. A bin with no finite value (all-missing or all-non-finite)
+            // keeps the NaN empty-bin sentinel.
+            for (let b = 0; b < bins; b += 1) {
+                const start = Math.floor((b * n) / bins);
+                const end = Math.floor(((b + 1) * n) / bins);
+                let loVal;
+                let hiVal;
+                for (let i = start; i < end; i += 1) {
+                    if (validity !== undefined && !validity.isDefined(i))
+                        continue;
+                    const x = values[i];
+                    if (!Number.isFinite(x))
+                        continue;
+                    if (loVal === undefined) {
+                        loVal = x;
+                        hiVal = x;
+                    }
+                    else {
+                        if (x < loVal)
+                            loVal = x;
+                        if (x > hiVal)
+                            hiVal = x;
+                    }
+                }
+                if (loVal === undefined) {
+                    lo[b] = NaN;
+                    hi[b] = NaN;
+                }
+                else {
+                    lo[b] = loVal;
+                    hi[b] = hiVal;
+                }
+            }
+            return { lo, hi };
+        }
         if (validity === undefined) {
             for (let b = 0; b < bins; b += 1) {
                 const start = Math.floor((b * n) / bins);
@@ -568,10 +633,15 @@ ChunkedFloat64Column.prototype.percentile = function (q) {
     return materializeChunkedFloat64(this).percentile(q);
 };
 ChunkedFloat64Column.prototype.count = function () {
-    // Validity-defined-count is available without materializing.
-    if (!this.validity)
-        return this.length;
-    return this.validity.definedCount;
+    // The O(1) defined-count is correct only when the column is provably
+    // finite. Non-finite cells are skipped (reducer non-finite policy —
+    // docs/notes/reducer-nan-policy.md), so when finiteness isn't proven,
+    // delegate to the materialized packed `count()` (which routes through the
+    // count reducer and skips non-finite) — matching packed `Float64Column`.
+    if (this.allFinite) {
+        return this.validity ? this.validity.definedCount : this.length;
+    }
+    return materializeChunkedFloat64(this).count();
 };
 ChunkedFloat64Column.prototype.minMax = function () {
     return materializeChunkedFloat64(this).minMax();

package/dist/columnar/chunked-column.d.ts

@@ -72,6 +72,16 @@ export declare class ChunkedFloat64Column {
     readonly chunks: ReadonlyArray<Float64Column>;
     readonly chunkOffsets: Int32Array;
     readonly validity?: ValidityBitmap;
+    /**
+     * `true` iff **every** chunk is itself `allFinite` — the merged
+     * column is all-finite IFF each input is (an AND). Defaults to
+     * `false` whenever any chunk's flag is `false` (or absent), which is
+     * the safe direction: a chunk that didn't prove finiteness keeps the
+     * whole column on the guarded reducer path. Mirrors
+     * `Float64Column.allFinite`'s safety contract — see it for why a
+     * wrong `true` is unsafe.
+     */
+    readonly allFinite: boolean;
     constructor(chunks: ReadonlyArray<Float64Column>);
     /**
      * Reads cell `i` by binary-searching `chunkOffsets` to find the

package/dist/columnar/chunked-column.js

@@ -192,6 +192,16 @@ export class ChunkedFloat64Column {
     chunks;
     chunkOffsets;
     validity;
+    /**
+     * `true` iff **every** chunk is itself `allFinite` — the merged
+     * column is all-finite IFF each input is (an AND). Defaults to
+     * `false` whenever any chunk's flag is `false` (or absent), which is
+     * the safe direction: a chunk that didn't prove finiteness keeps the
+     * whole column on the guarded reducer path. Mirrors
+     * `Float64Column.allFinite`'s safety contract — see it for why a
+     * wrong `true` is unsafe.
+     */
+    allFinite;
     constructor(chunks) {
         assertChunkKinds(chunks, 'number', 'ChunkedFloat64Column');
         const { length, chunkOffsets, validity } = buildOffsetsAndAggregateValidity(chunks, 'ChunkedFloat64Column');
@@ -202,6 +212,16 @@ export class ChunkedFloat64Column {
         this.chunkOffsets = chunkOffsets;
         if (validity !== undefined)
             this.validity = validity;
+        // AND across chunks: all-finite IFF every chunk is. An empty chunk
+        // list is vacuously all-finite (no non-finite cell exists).
+        let allFinite = true;
+        for (let c = 0; c < chunks.length; c += 1) {
+            if (!chunks[c].allFinite) {
+                allFinite = false;
+                break;
+            }
+        }
+        this.allFinite = allFinite;
     }
     /**
      * Reads cell `i` by binary-searching `chunkOffsets` to find the
@@ -287,10 +307,13 @@ export class ChunkedFloat64Column {
             out[i] = this.chunks[c]._values[local];
             validBits[i >> 3] |= 1 << (i & 7);
         }
+        // A gather only reads existing defined cells (out-of-range / invalid
+        // slots are skipped → marked invalid below), so the result is finite
+        // whenever this chunked column is. Propagate the AND-of-chunks flag.
         if (!hasInvalid) {
-            return new Float64Column(out, indices.length);
+            return new Float64Column(out, indices.length, undefined, this.allFinite);
         }
-        return new Float64Column(out, indices.length, validityFromBits(validBits, indices.length));
+        return new Float64Column(out, indices.length, validityFromBits(validBits, indices.length), this.allFinite);
     }
 }
 /* -------------------------------------------------------------------------- */
@@ -631,7 +654,10 @@ export function materializeChunkedFloat64(chunked) {
         out.set(chunk._values.subarray(0, chunk.length), cursor);
         cursor += chunk.length;
     }
-    return new Float64Column(out, chunked.length, chunked.validity);
+    // Compacting doesn't touch values, so finiteness carries over from
+    // the chunked column (which is the AND of its chunks). This is what
+    // lets a `concatSorted(...).reduce(...)` take the reducer fast path.
+    return new Float64Column(out, chunked.length, chunked.validity, chunked.allFinite);
 }
 /**
  * Compacts a `ChunkedBooleanColumn` into a plain `BooleanColumn`.

package/dist/columnar/column.d.ts

@@ -128,7 +128,25 @@ export declare class Float64Column implements ColumnBase<number, 'number'> {
     readonly storage: "packed";
     readonly length: number;
     readonly validity?: ValidityBitmap;
-    constructor(values: Float64Array, length: number, validity?: ValidityBitmap);
+    /**
+     * **Safety contract.** `true` MUST mean "every *defined* cell is
+     * finite — no `NaN`, no `±Infinity`" (missing cells, tracked by
+     * `validity`, are irrelevant). It is a promise the producer makes
+     * so reducers can skip the per-element `Number.isFinite` guard that
+     * the reducer non-finite policy (docs/notes/reducer-nan-policy.md)
+     * otherwise requires on every numeric `reduceColumn`.
+     *
+     * A wrongly-`true` flag makes `reduceColumn` take the unguarded fast
+     * path and silently include a non-finite cell → wrong result. So the
+     * **default is `false`** (conservative: guarded path, correct-but-
+     * slower) and a producer sets `true` ONLY where finiteness is proven
+     * — either data-derived by inspecting every cell, validated upstream
+     * (strict intake), or propagated from a source column that was
+     * itself `allFinite`. When unsure, leave it `false`: a missed `true`
+     * is slower, never wrong.
+     */
+    readonly allFinite: boolean;
+    constructor(values: Float64Array, length: number, validity?: ValidityBitmap, allFinite?: boolean);
     read(i: number): number | undefined;
     scan(fn: (value: number, i: number) => void, options?: ScanOptions): void;
     sliceByRange(start: number, end: number): Float64Column;

package/dist/columnar/column.js

@@ -41,7 +41,25 @@ export class Float64Column {
      */
     _values;
     validity;
-    constructor(values, length, validity) {
+    /**
+     * **Safety contract.** `true` MUST mean "every *defined* cell is
+     * finite — no `NaN`, no `±Infinity`" (missing cells, tracked by
+     * `validity`, are irrelevant). It is a promise the producer makes
+     * so reducers can skip the per-element `Number.isFinite` guard that
+     * the reducer non-finite policy (docs/notes/reducer-nan-policy.md)
+     * otherwise requires on every numeric `reduceColumn`.
+     *
+     * A wrongly-`true` flag makes `reduceColumn` take the unguarded fast
+     * path and silently include a non-finite cell → wrong result. So the
+     * **default is `false`** (conservative: guarded path, correct-but-
+     * slower) and a producer sets `true` ONLY where finiteness is proven
+     * — either data-derived by inspecting every cell, validated upstream
+     * (strict intake), or propagated from a source column that was
+     * itself `allFinite`. When unsure, leave it `false`: a missed `true`
+     * is slower, never wrong.
+     */
+    allFinite;
+    constructor(values, length, validity, allFinite = false) {
         validateColumnLength(length, 'Float64Column');
         if (length > values.length) {
             throw new RangeError(`Float64Column buffer underflow: length ${length} exceeds values.length ${values.length}`);
@@ -53,6 +71,7 @@ export class Float64Column {
         this.length = length;
         if (validity !== undefined)
             this.validity = validity;
+        this.allFinite = allFinite;
     }
     read(i) {
         if (i < 0 || i >= this.length)
@@ -88,7 +107,8 @@ export class Float64Column {
         }
         const valuesSlice = this._values.subarray(lo, hi);
         const validitySlice = validitySliceByRange(this.validity, lo, hi, this.length);
-        return new Float64Column(valuesSlice, hi - lo, validitySlice);
+        // A contiguous slice of an all-finite column is all-finite.
+        return new Float64Column(valuesSlice, hi - lo, validitySlice, this.allFinite);
     }
     sliceByIndices(indices) {
         const out = new Float64Array(indices.length);
@@ -99,7 +119,10 @@ export class Float64Column {
             out[i] = idx >= 0 && idx < this.length ? this._values[idx] : 0;
         }
         const validity = validityGatherByIndices(this.validity, indices, this.length);
-        return new Float64Column(out, indices.length, validity);
+        // A gathered subset of finite cells is finite. Out-of-range slots
+        // read 0 (finite) and are marked invalid by the validity gather, so
+        // they can't violate the contract either way.
+        return new Float64Column(out, indices.length, validity, this.allFinite);
     }
 }
 /* -------------------------------------------------------------------------- */
@@ -201,15 +224,27 @@ export function float64ColumnFromArray(source) {
     const length = source.length;
     validateColumnLength(length, 'Float64Column');
     const values = new Float64Array(length);
+    // Data-derive `allFinite` in the copy loop: only *defined* cells
+    // count (a missing slot doesn't make the column non-finite). Finite
+    // data → `true` (reducers take the fast path); an overflow / NaN cell
+    // → `false` (guarded path, correct). See the field's safety contract.
+    let allFinite = true;
     for (let i = 0; i < length; i += 1) {
         const v = source[i];
-        values[i] = typeof v === 'number' ? v : 0;
+        if (typeof v === 'number') {
+            values[i] = v;
+            if (!Number.isFinite(v))
+                allFinite = false;
+        }
+        else {
+            values[i] = 0;
+        }
     }
     const validity = validityFromPredicate(length, (i) => {
         const v = source[i];
         return typeof v === 'number';
     });
-    return new Float64Column(values, length, validity);
+    return new Float64Column(values, length, validity, allFinite);
 }
 /**
  * Builds a `BooleanColumn` from an array of `boolean | null | undefined`

package/dist/reducers/avg.js

@@ -8,24 +8,51 @@ export const avg = {
     reduceColumn(col) {
         const values = col._values;
         const validity = col.validity;
+        let s = 0;
+        let n = 0;
+        // Fast path: every defined cell is finite (`Float64Column.allFinite`),
+        // so every defined cell is a valid contributor — plain accumulate, and
+        // the divisor is `definedCount` (or `col.length`). Drops the
+        // per-element finite guard the reducer non-finite policy
+        // (docs/notes/reducer-nan-policy.md) otherwise requires.
+        if (col.allFinite) {
+            if (validity === undefined) {
+                for (let i = 0; i < col.length; i += 1)
+                    s += values[i];
+                return col.length === 0 ? undefined : s / col.length;
+            }
+            const bits = validity.bits;
+            for (let i = 0; i < col.length; i += 1) {
+                if ((bits[i >> 3] & (1 << (i & 7))) !== 0)
+                    s += values[i];
+            }
+            const count = validity.definedCount;
+            return count === 0 ? undefined : s / count;
+        }
+        // Guarded path: divide by the count of *finite* contributors, not
+        // `definedCount` — a non-finite cell is skipped per policy, so it must
+        // not inflate the divisor.
         if (validity === undefined) {
-            if (col.length === 0)
-                return undefined;
-            let s = 0;
-            for (let i = 0; i < col.length; i += 1)
-                s += values[i];
-            return s / col.length;
+            for (let i = 0; i < col.length; i += 1) {
+                const v = values[i];
+                if (Number.isFinite(v)) {
+                    s += v;
+                    n += 1;
+                }
+            }
+            return n === 0 ? undefined : s / n;
         }
-        const definedCount = validity.definedCount;
-        if (definedCount === 0)
-            return undefined;
         const bits = validity.bits;
-        let s = 0;
         for (let i = 0; i < col.length; i += 1) {
-            if ((bits[i >> 3] & (1 << (i & 7))) !== 0)
-                s += values[i];
+            if ((bits[i >> 3] & (1 << (i & 7))) !== 0) {
+                const v = values[i];
+                if (Number.isFinite(v)) {
+                    s += v;
+                    n += 1;
+                }
+            }
         }
-        return s / definedCount;
+        return n === 0 ? undefined : s / n;
     },
     bucketState() {
         let s = 0;

package/dist/reducers/count.js

@@ -24,10 +24,36 @@ export const count = {
         return defined.length;
     },
     reduceColumn(col) {
-        // O(1) when validity is precomputed (it always is on Float64Column —
-        // `validity.definedCount` is cached at construction). Falls back to
-        // `col.length` when no validity bitmap exists (every cell defined).
-        return col.validity === undefined ? col.length : col.validity.definedCount;
+        const values = col._values;
+        const validity = col.validity;
+        // Fast path: every defined cell is finite (`Float64Column.allFinite`),
+        // so "defined" and "defined AND finite" coincide — the O(1) shortcut
+        // is exact again (`definedCount`, or `col.length` when no bitmap).
+        // This is the O(N)→O(1) recovery the non-finite policy cost count
+        // (docs/notes/reducer-nan-policy.md).
+        if (col.allFinite) {
+            return validity === undefined ? col.length : validity.definedCount;
+        }
+        // Guarded path: O(N) scan, NOT the `definedCount` shortcut — the
+        // non-finite policy excludes non-finite cells, and `definedCount`
+        // counts them as present, so a defined-but-NaN cell would over-count.
+        // Walk and count valid AND finite cells.
+        let n = 0;
+        if (validity === undefined) {
+            for (let i = 0; i < col.length; i += 1) {
+                if (Number.isFinite(values[i]))
+                    n += 1;
+            }
+            return n;
+        }
+        const bits = validity.bits;
+        for (let i = 0; i < col.length; i += 1) {
+            if ((bits[i >> 3] & (1 << (i & 7))) !== 0 &&
+                Number.isFinite(values[i])) {
+                n += 1;
+            }
+        }
+        return n;
     },
     bucketState() {
         let n = 0;

package/dist/reducers/index.js

@@ -41,6 +41,38 @@ export function resolveReducer(operation) {
         return topReducer(n);
     throw new TypeError(`unsupported aggregate reducer: ${operation}`);
 }
+/**
+ * Non-finite numerics (`NaN` / `±Infinity`) are treated as **missing** by
+ * every built-in reducer — the reducer non-finite policy
+ * (docs/notes/reducer-nan-policy.md). Row intake keeps user data finite; these
+ * values only arise inside computed columns (e.g. `cumulative` overflow) or
+ * trusted construction, and skipping them keeps every reducer consistent
+ * across all four execution paths. Mapping to `undefined` here lets the
+ * existing skip-missing logic in each incremental state do the work — so the
+ * policy holds for both the batch and live incremental paths without touching
+ * any reducer body. Custom-function reducers are intentionally NOT wrapped:
+ * they receive values as-is (the escape hatch decides its own semantics).
+ */
+function finiteOrMissing(value) {
+    return typeof value === 'number' && !Number.isFinite(value)
+        ? undefined
+        : value;
+}
+/** Wrap a bucket state so non-finite numerics are skipped. {@link finiteOrMissing} */
+function skipNonFiniteBucket(state) {
+    return {
+        add: (value) => state.add(finiteOrMissing(value)),
+        snapshot: () => state.snapshot(),
+    };
+}
+/** Wrap a rolling state so non-finite numerics are skipped. {@link finiteOrMissing} */
+function skipNonFiniteRolling(state) {
+    return {
+        add: (index, value) => state.add(index, finiteOrMissing(value)),
+        remove: (index, value) => state.remove(index, finiteOrMissing(value)),
+        snapshot: () => state.snapshot(),
+    };
+}
 /**
  * Build an `AggregateBucketState` for a reducer that may be either a
  * built-in name (string) or a custom function. Built-ins use their
@@ -52,7 +84,7 @@ export function resolveReducer(operation) {
  */
 export function bucketStateFor(reducer) {
     if (typeof reducer === 'string') {
-        return resolveReducer(reducer).bucketState();
+        return skipNonFiniteBucket(resolveReducer(reducer).bucketState());
     }
     // Custom-function adapter: buffer values, call fn at snapshot time.
     const items = [];
@@ -90,7 +122,7 @@ export function bucketStateFor(reducer) {
  */
 export function rollingStateFor(reducer) {
     if (typeof reducer === 'string') {
-        return resolveReducer(reducer).rollingState();
+        return skipNonFiniteRolling(resolveReducer(reducer).rollingState());
     }
     // Custom-function adapter: Map keyed by event index for O(1) remove.
     const items = new Map();

package/dist/reducers/max.js

@@ -7,20 +7,46 @@ export const max = {
             : numeric.reduce((a, b) => (a >= b ? a : b));
     },
     reduceColumn(col) {
-        // **NaN parity with row API.** Mirror the row-API expression
-        //   numeric.reduce((a, b) => a >= b ? a : b)
-        // exactly. See `min.ts` for the full rationale. Closed Codex
-        // review finding on PR #153.
         const values = col._values;
         const validity = col.validity;
         let hi;
-        if (validity === undefined) {
-            if (col.length === 0)
+        // Fast path: every defined cell is finite (`Float64Column.allFinite`),
+        // so we seed `hi` from the first defined cell and run a plain `v > hi`
+        // compare with NO per-element `Number.isFinite` guard and NO in-loop
+        // `hi === undefined` check (the seed hoists it out). No NaN to mishandle,
+        // also sidesteps the position-dependent `a>=b?a:b` extremum bug the policy
+        // fixed (docs/notes/reducer-nan-policy.md). The pre-policy column loop,
+        // recovered.
+        if (col.allFinite) {
+            const len = col.length;
+            if (len === 0)
                 return undefined;
-            hi = values[0];
-            for (let i = 1; i < col.length; i += 1) {
+            if (validity === undefined) {
+                hi = values[0];
+                for (let i = 1; i < len; i += 1) {
+                    const v = values[i];
+                    if (v > hi)
+                        hi = v;
+                }
+                return hi;
+            }
+            const bits = validity.bits;
+            for (let i = 0; i < len; i += 1) {
+                if ((bits[i >> 3] & (1 << (i & 7))) === 0)
+                    continue;
+                const v = values[i];
+                if (hi === undefined || v > hi)
+                    hi = v;
+            }
+            return hi;
+        }
+        // Guarded path: skip non-finite cells (reducer non-finite policy) —
+        // matches `bucketState`'s `v > hi`.
+        if (validity === undefined) {
+            for (let i = 0; i < col.length; i += 1) {
                 const v = values[i];
-                hi = hi >= v ? hi : v;
+                if (Number.isFinite(v) && (hi === undefined || v > hi))
+                    hi = v;
             }
             return hi;
         }
@@ -29,7 +55,8 @@ export const max = {
             if ((bits[i >> 3] & (1 << (i & 7))) === 0)
                 continue;
             const v = values[i];
-            hi = hi === undefined ? v : hi >= v ? hi : v;
+            if (Number.isFinite(v) && (hi === undefined || v > hi))
+                hi = v;
         }
         return hi;
     },

package/dist/reducers/min.js

@@ -7,33 +7,46 @@ export const min = {
             : numeric.reduce((a, b) => (a <= b ? a : b));
     },
     reduceColumn(col) {
-        // **NaN parity with row API.** The row-API path uses
-        //   numeric.reduce((a, b) => a <= b ? a : b)
-        // which has surprising NaN behavior: on `[1, NaN, 2]` it returns
-        // `2` because the first `1 <= NaN` is false (returning NaN),
-        // then `NaN <= 2` is also false (returning 2). The "natural"
-        // column-side loop `if (v < lo) lo = v` would instead return
-        // `1` (NaN comparisons always false → NaN is skipped). The two
-        // paths diverge on NaN-bearing input.
-        //
-        // We mirror the row-API comparison expression exactly to
-        // preserve the parity claim, even though both paths exhibit
-        // surprising results on NaN (which can only reach a `kind:
-        // 'number'` column via trusted construction — `assertCellKind`
-        // rejects it at public intake). Closed Codex review finding on
-        // PR #153. A principled "filter NaN consistently across both
-        // paths" fix is a separate concern tracked in the followup
-        // issue.
         const values = col._values;
         const validity = col.validity;
         let lo;
-        if (validity === undefined) {
-            if (col.length === 0)
+        // Fast path: every defined cell is finite (`Float64Column.allFinite`),
+        // so we seed `lo` from the first defined cell and run a plain `v < lo`
+        // compare with NO per-element `Number.isFinite` guard and NO in-loop
+        // `lo === undefined` check (the seed hoists it out). There is no NaN to
+        // mishandle, so this also sidesteps the position-dependent `a<=b?a:b`
+        // extremum bug the policy fixed (docs/notes/reducer-nan-policy.md). This
+        // is the pre-policy column loop, recovered.
+        if (col.allFinite) {
+            const len = col.length;
+            if (len === 0)
                 return undefined;
-            lo = values[0];
-            for (let i = 1; i < col.length; i += 1) {
+            if (validity === undefined) {
+                lo = values[0];
+                for (let i = 1; i < len; i += 1) {
+                    const v = values[i];
+                    if (v < lo)
+                        lo = v;
+                }
+                return lo;
+            }
+            const bits = validity.bits;
+            for (let i = 0; i < len; i += 1) {
+                if ((bits[i >> 3] & (1 << (i & 7))) === 0)
+                    continue;
+                const v = values[i];
+                if (lo === undefined || v < lo)
+                    lo = v;
+            }
+            return lo;
+        }
+        // Guarded path: skip non-finite cells (reducer non-finite policy) —
+        // matches `bucketState`'s `v < lo`.
+        if (validity === undefined) {
+            for (let i = 0; i < col.length; i += 1) {
                 const v = values[i];
-                lo = lo <= v ? lo : v;
+                if (Number.isFinite(v) && (lo === undefined || v < lo))
+                    lo = v;
             }
             return lo;
         }
@@ -42,7 +55,8 @@ export const min = {
             if ((bits[i >> 3] & (1 << (i & 7))) === 0)
                 continue;
             const v = values[i];
-            lo = lo === undefined ? v : lo <= v ? lo : v;
+            if (Number.isFinite(v) && (lo === undefined || v < lo))
+                lo = v;
         }
         return lo;
     },