fix: bigint AVG precision loss for sums exceeding 2^53

Number(bigintSum) in AVG computation lost precision when the running
sum exceeded Number.MAX_SAFE_INTEGER. Added bigIntAvg() helpers that
divide in BigInt space first (quotient + remainder) to preserve
precision. Fixed in partial-agg.ts (GROUP BY AVG) and operators.ts
(window AVG, both running and frame paths).

Author: teamchong

src/operators.ts

@@ -40,6 +40,13 @@ import {
   type PartialAgg,
 } from "./partial-agg.js";
 
+/** Compute AVG from bigint sum without losing precision for sums > 2^53.
+ *  Divides in BigInt space, handles remainder as float. */
+function bigIntAvg(sum: bigint, count: number): number {
+  const bigCount = BigInt(count);
+  return Number(sum / bigCount) + Number(sum % bigCount) / count;
+}
+
 /** A batch of rows flowing through the pipeline. */
 export type RowBatch = Row[];
 
@@ -1109,7 +1116,7 @@ export class WindowOperator implements Operator {
         }
         switch (fn) {
           case "sum": rows[indices[i]][alias] = runCount === 0 ? null : runSum; break;
-          case "avg": rows[indices[i]][alias] = runCount === 0 ? null : Number(runSum) / runCount; break;
+          case "avg": rows[indices[i]][alias] = runCount === 0 ? null : bigIntAvg(runSum, runCount); break;
           case "min": rows[indices[i]][alias] = runMin ?? null; break;
           case "max": rows[indices[i]][alias] = runMax ?? null; break;
           case "count": rows[indices[i]][alias] = runCount; break;
@@ -1133,7 +1140,7 @@ export class WindowOperator implements Operator {
       }
       switch (fn) {
         case "sum": rows[indices[i]][alias] = count === 0 ? null : sum; break;
-        case "avg": rows[indices[i]][alias] = count === 0 ? null : Number(sum) / count; break;
+        case "avg": rows[indices[i]][alias] = count === 0 ? null : bigIntAvg(sum, count); break;
         case "min": rows[indices[i]][alias] = min ?? null; break;
         case "max": rows[indices[i]][alias] = max ?? null; break;
         case "count": rows[indices[i]][alias] = count; break;

src/partial-agg.ts

@@ -34,6 +34,15 @@ export interface PartialAggState {
   bigMax?: bigint;
 }
 
+/** Compute AVG from bigint sum + number sum without losing precision for large sums. */
+function bigAvg(bigSum: bigint, numSum: number, count: number): number {
+  const bigCount = BigInt(count);
+  // Integer part from bigint division, remainder handled as float
+  const quotient = Number(bigSum / bigCount);
+  const remainder = Number(bigSum % bigCount);
+  return quotient + (remainder + numSum) / count;
+}
+
 export function initPartialAggState(
   fn: PartialAggState["fn"],
   column: string,
@@ -102,7 +111,7 @@ function resolveValue(state: PartialAggState): number | bigint | string | null {
   const hasBig = state.bigSum !== undefined;
   switch (state.fn) {
     case "sum": return hasBig ? (state.bigSum! + BigInt(Math.trunc(state.sum))) : state.sum;
-    case "avg": return hasBig ? (Number(state.bigSum!) + state.sum) / state.count : state.sum / state.count;
+    case "avg": return hasBig ? bigAvg(state.bigSum!, state.sum, state.count) : state.sum / state.count;
     case "min": return state.strMin !== undefined ? state.strMin : hasBig ? state.bigMin! : state.min;
     case "max": return state.strMax !== undefined ? state.strMax : hasBig ? state.bigMax! : state.max;
     case "stddev": return state.count < 2 ? null : Math.sqrt(Math.max(0, (state.m2 ?? 0) / state.count));