lakeql 0.1.8 → 0.2.0

package/dist/window-backend-OECETVJ2.js

@@ -0,0 +1,905 @@
+import { partitionRows, sortWindowRows, partitionSpans, compatibleWindowSortGroups, stableKey, normalizedWindowName, isAggregateWindow, samePeer, compareWindowRows, requireExactWindowAggregate, filterRow, numericAggregateValue, compareAggregateScalars } from './chunk-LWF5FKHB.js';
+import { LakeqlError, evaluate, jsonSafeValue, isTimestampValue, applyIntervalToTimestamp, isIntervalValue, isNonNegativeInterval } from './chunk-WGHR35QU.js';
+
+// ../core/dist/window-aggregate.js
+function aggregateWindowValue(rows, expr) {
+  if (typeof expr.fn !== "object") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Window expression is not an aggregate");
+  }
+  const op = expr.fn.aggregate;
+  requireExactWindowAggregate(op);
+  const state = new AggregateState(op, quantile(expr));
+  for (const row of rows) {
+    if (!filterRow(expr, row))
+      continue;
+    const value = aggregateInputValue(expr, row);
+    state.add(value, expr.distinct === true);
+  }
+  return state.value();
+}
+function aggregateInputValue(expr, row) {
+  if (expr.args.length === 0)
+    return 1;
+  const arg = expr.args[0];
+  if (arg === void 0)
+    return 1;
+  return evaluate(arg, row);
+}
+var AggregateState = class {
+  op;
+  quantile;
+  count = 0;
+  sum = 0;
+  mean = 0;
+  m2 = 0;
+  min;
+  max;
+  first;
+  last;
+  values = [];
+  modeValues = /* @__PURE__ */ new Map();
+  seenDistinct = /* @__PURE__ */ new Set();
+  constructor(op, quantile2) {
+    this.op = op;
+    this.quantile = quantile2;
+  }
+  add(value, distinct) {
+    if (this.op === "count") {
+      if (value !== null && this.addDistinct(value, distinct))
+        this.count += 1;
+      return;
+    }
+    if (value === null || !this.addDistinct(value, distinct))
+      return;
+    switch (this.op) {
+      case "sum":
+      case "avg":
+        this.addNumber(value);
+        break;
+      case "var_samp":
+      case "var_pop":
+      case "stddev_samp":
+      case "stddev_pop":
+        this.addVariance(value);
+        break;
+      case "min":
+        if (this.min === void 0 || compareScalar(value, this.min) < 0)
+          this.min = value;
+        break;
+      case "max":
+        if (this.max === void 0 || compareScalar(value, this.max) > 0)
+          this.max = value;
+        break;
+      case "first":
+      case "any":
+        if (this.first === void 0)
+          this.first = value;
+        break;
+      case "last":
+        this.last = value;
+        break;
+      case "median":
+      case "quantile":
+        this.values.push(numericValue(this.op, value));
+        break;
+      case "mode":
+        this.addMode(value);
+        break;
+      case "count_distinct":
+        this.count += 1;
+        break;
+      case "approx_count_distinct":
+        requireExactWindowAggregate(this.op);
+        break;
+    }
+  }
+  value() {
+    switch (this.op) {
+      case "count":
+      case "count_distinct":
+        return this.count;
+      case "sum":
+        return this.count === 0 ? null : this.sum;
+      case "avg":
+        return this.count === 0 ? null : this.sum / this.count;
+      case "var_samp":
+        return this.count <= 1 ? null : this.m2 / (this.count - 1);
+      case "var_pop":
+        return this.count === 0 ? null : this.m2 / this.count;
+      case "stddev_samp":
+        return this.count <= 1 ? null : Math.sqrt(this.m2 / (this.count - 1));
+      case "stddev_pop":
+        return this.count === 0 ? null : Math.sqrt(this.m2 / this.count);
+      case "min":
+        return this.min ?? null;
+      case "max":
+        return this.max ?? null;
+      case "first":
+      case "any":
+        return this.first ?? null;
+      case "last":
+        return this.last ?? null;
+      case "median":
+        return continuousQuantile(this.values, 0.5);
+      case "quantile":
+        return continuousQuantile(this.values, this.quantile ?? 0.5);
+      case "mode":
+        return this.mode();
+      case "approx_count_distinct":
+        requireExactWindowAggregate(this.op);
+        return null;
+    }
+  }
+  addDistinct(value, distinct) {
+    if (!distinct && this.op !== "count_distinct")
+      return true;
+    const key = JSON.stringify(jsonSafeValue(value));
+    if (this.seenDistinct.has(key))
+      return false;
+    this.seenDistinct.add(key);
+    return true;
+  }
+  addNumber(value) {
+    const numeric = numericValue(this.op, value);
+    this.sum += numeric;
+    this.count += 1;
+  }
+  addVariance(value) {
+    const numeric = numericValue(this.op, value);
+    this.count += 1;
+    const delta = numeric - this.mean;
+    this.mean += delta / this.count;
+    this.m2 += delta * (numeric - this.mean);
+  }
+  addMode(value) {
+    const key = JSON.stringify(jsonSafeValue(value));
+    const current = this.modeValues.get(key);
+    if (current === void 0) {
+      this.modeValues.set(key, { value, count: 1 });
+      return;
+    }
+    current.count += 1;
+  }
+  mode() {
+    let best;
+    for (const entry of this.modeValues.values()) {
+      if (best === void 0 || entry.count > best.count || entry.count === best.count && compareScalar(entry.value, best.value) < 0) {
+        best = entry;
+      }
+    }
+    return best?.value ?? null;
+  }
+};
+function quantile(expr) {
+  if (typeof expr.fn !== "object" || expr.fn.aggregate !== "quantile")
+    return void 0;
+  const arg = expr.args[1];
+  if (arg === void 0 || arg.kind !== "literal" || typeof arg.value !== "number") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "quantile_cont window percentile must be numeric");
+  }
+  if (!Number.isFinite(arg.value) || arg.value < 0 || arg.value > 1) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "quantile_cont percentile must be between 0 and 1");
+  }
+  return arg.value;
+}
+function continuousQuantile(values, q) {
+  const sorted = values.map((value) => numericValue("quantile", value)).sort((a, b) => a - b);
+  if (sorted.length === 0)
+    return null;
+  const position = (sorted.length - 1) * q;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  const lowerValue = sorted[lower] ?? 0;
+  const upperValue = sorted[upper] ?? lowerValue;
+  return lowerValue + (upperValue - lowerValue) * (position - lower);
+}
+function numericValue(op, value) {
+  return numericAggregateValue(op, value);
+}
+function compareScalar(left, right) {
+  return compareAggregateScalars(left, right);
+}
+
+// ../core/dist/window-frame.js
+function frameRows(partition, index, expr) {
+  const span = frameSpan(partition, index, expr);
+  const excluded = excludedRows(partition, index, span, expr.over.frame);
+  const out = [];
+  for (let rowIndex = span.start; rowIndex < span.end; rowIndex += 1) {
+    if (excluded.has(rowIndex))
+      continue;
+    const row = partition[rowIndex]?.row;
+    if (row !== void 0)
+      out.push(row);
+  }
+  return out;
+}
+function frameSpan(partition, index, expr) {
+  const frame = effectiveFrame(expr);
+  switch (frame.mode) {
+    case "rows":
+      return rowsFrameSpan(partition, index, frame);
+    case "groups":
+      return groupsFrameSpan(partition, index, frame);
+    case "range":
+      return rangeFrameSpan(partition, index, expr, frame);
+  }
+}
+function effectiveFrame(expr) {
+  if (expr.over.frame !== void 0)
+    return expr.over.frame;
+  if (expr.over.orderBy.length === 0) {
+    return {
+      mode: "rows",
+      start: { kind: "unbounded-preceding" },
+      end: { kind: "unbounded-following" },
+      exclude: "no-others"
+    };
+  }
+  return {
+    mode: "range",
+    start: { kind: "unbounded-preceding" },
+    end: { kind: "current-row" },
+    exclude: "no-others"
+  };
+}
+function rowsFrameSpan(partition, index, frame) {
+  return normalizeSpan(partition.length, {
+    start: rowBoundIndex(partition, index, frame.start),
+    end: rowBoundIndex(partition, index, frame.end) + 1
+  });
+}
+function rowBoundIndex(partition, index, bound) {
+  switch (bound.kind) {
+    case "unbounded-preceding":
+      return 0;
+    case "unbounded-following":
+      return partition.length - 1;
+    case "current-row":
+      return index;
+    case "preceding":
+      return index - offset(bound, partition[index]?.row);
+    case "following":
+      return index + offset(bound, partition[index]?.row);
+  }
+}
+function groupsFrameSpan(partition, index, frame) {
+  const groups = peerGroups(partition);
+  const groupIndex = groups.findIndex((group) => index >= group.start && index < group.end);
+  if (groupIndex === -1)
+    return { start: 0, end: 0 };
+  const startGroup = groupBoundIndex(groups.length, groupIndex, frame.start, partition[index]?.row);
+  const endGroup = groupBoundIndex(groups.length, groupIndex, frame.end, partition[index]?.row);
+  if (endGroup < 0 || startGroup >= groups.length)
+    return { start: 0, end: 0 };
+  const clampedStartGroup = clamp(startGroup, 0, groups.length - 1);
+  const clampedEndGroup = clamp(endGroup, 0, groups.length - 1);
+  return normalizeSpan(partition.length, {
+    start: groups[clampedStartGroup]?.start ?? 0,
+    end: groups[clampedEndGroup]?.end ?? partition.length
+  });
+}
+function groupBoundIndex(groupCount, groupIndex, bound, row) {
+  switch (bound.kind) {
+    case "unbounded-preceding":
+      return 0;
+    case "unbounded-following":
+      return groupCount - 1;
+    case "current-row":
+      return groupIndex;
+    case "preceding":
+      return groupIndex - offset(bound, row);
+    case "following":
+      return groupIndex + offset(bound, row);
+  }
+}
+function rangeFrameSpan(partition, index, expr, frame) {
+  if (frame.start.offset !== void 0 || frame.end.offset !== void 0) {
+    return rangeOffsetFrameSpan(partition, index, expr, frame);
+  }
+  const peer = peerSpan(partition, index);
+  return normalizeSpan(partition.length, {
+    start: rangeEndpoint(partition.length, peer, frame.start, "start"),
+    end: rangeEndpoint(partition.length, peer, frame.end, "end") + 1
+  });
+}
+function rangeEndpoint(rowCount, peer, bound, side) {
+  switch (bound.kind) {
+    case "unbounded-preceding":
+      return 0;
+    case "unbounded-following":
+      return rowCount - 1;
+    case "current-row":
+      return side === "start" ? peer.start : peer.end - 1;
+    case "preceding":
+    case "following":
+      throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "RANGE offset frames require the range-offset backend");
+  }
+}
+function rangeOffsetFrameSpan(partition, index, expr, frame) {
+  if (expr.over.orderBy.length !== 1) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "RANGE offset frames require exactly one ORDER BY expression");
+  }
+  const direction = expr.over.orderBy[0]?.direction ?? "asc";
+  const current = rangePoint(partition[index]?.orderKey[0], direction);
+  const start = rangeOffsetBound(current, frame.start, partition[index]?.row, direction);
+  const end = rangeOffsetBound(current, frame.end, partition[index]?.row, direction);
+  let first = 0;
+  while (first < partition.length && compareRangeValues(rangePoint(partition[first]?.orderKey[0], direction).normalized, start) < 0) {
+    first += 1;
+  }
+  let afterLast = first;
+  while (afterLast < partition.length && compareRangeValues(rangePoint(partition[afterLast]?.orderKey[0], direction).normalized, end) <= 0) {
+    afterLast += 1;
+  }
+  return normalizeSpan(partition.length, { start: first, end: afterLast });
+}
+function rangeOffsetBound(current, bound, row, direction) {
+  switch (bound.kind) {
+    case "unbounded-preceding":
+      return current.kind === "number" ? -Infinity : -rangeInfinity();
+    case "unbounded-following":
+      return current.kind === "number" ? Infinity : rangeInfinity();
+    case "current-row":
+      return current.normalized;
+    case "preceding":
+      if (current.kind === "number")
+        return current.normalized - numericRangeOffset(bound, row);
+      return shiftedTimestampRangeBound(current, bound, row, direction === "asc" ? -1 : 1, direction);
+    case "following":
+      if (current.kind === "number")
+        return current.normalized + numericRangeOffset(bound, row);
+      return shiftedTimestampRangeBound(current, bound, row, direction === "asc" ? 1 : -1, direction);
+  }
+}
+function shiftedTimestampRangeBound(current, bound, row, shiftDirection, direction) {
+  const interval = intervalRangeOffset(bound, row);
+  const shifted = applyIntervalToTimestamp(current.value, interval, shiftDirection);
+  return direction === "desc" ? -shifted.epochNanoseconds : shifted.epochNanoseconds;
+}
+function rangePoint(value, direction) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return { kind: "number", value, normalized: direction === "asc" ? value : -value };
+  }
+  if (isTimestampValue(value)) {
+    return {
+      kind: "timestamp",
+      value,
+      normalized: direction === "asc" ? value.epochNanoseconds : -value.epochNanoseconds
+    };
+  }
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", "RANGE offset frames require a non-null numeric or timestamp ORDER BY value");
+}
+function compareRangeValues(left, right) {
+  if (typeof left !== typeof right) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "RANGE frame bounds must have matching types");
+  }
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function rangeInfinity() {
+  return 1n << 255n;
+}
+function excludedRows(partition, index, span, frame) {
+  const exclude = frame?.exclude ?? "no-others";
+  const out = /* @__PURE__ */ new Set();
+  if (exclude === "no-others")
+    return out;
+  const peer = peerSpan(partition, index);
+  if (exclude === "current-row") {
+    out.add(index);
+    return out;
+  }
+  for (let rowIndex = Math.max(span.start, peer.start); rowIndex < Math.min(span.end, peer.end); rowIndex += 1) {
+    if (exclude === "ties" && rowIndex === index)
+      continue;
+    out.add(rowIndex);
+  }
+  return out;
+}
+function peerSpan(partition, index) {
+  let start = index;
+  while (start > 0 && samePeer(partition[start - 1], partition[index])) {
+    start -= 1;
+  }
+  let end = index + 1;
+  while (end < partition.length && samePeer(partition[index], partition[end])) {
+    end += 1;
+  }
+  return { start, end };
+}
+function peerGroups(partition) {
+  const groups = [];
+  let start = 0;
+  while (start < partition.length) {
+    const peer = peerSpan(partition, start);
+    groups.push(peer);
+    start = peer.end;
+  }
+  return groups;
+}
+function offset(bound, row) {
+  if (bound.offset === void 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Window frame offset is required");
+  }
+  const value = evaluate(bound.offset, row ?? {});
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Window frame offset must be a non-negative integer");
+  }
+  return value;
+}
+function numericRangeOffset(bound, row) {
+  if (bound.offset === void 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Window frame offset is required");
+  }
+  const value = evaluate(bound.offset, row ?? {});
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "RANGE frame offset must be a non-negative finite number");
+  }
+  return value;
+}
+function intervalRangeOffset(bound, row) {
+  if (bound.offset === void 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Window frame offset is required");
+  }
+  const value = evaluate(bound.offset, row ?? {});
+  if (!isIntervalValue(value) || !isNonNegativeInterval(value)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Timestamp RANGE frame offset must be a non-negative interval");
+  }
+  return value;
+}
+function normalizeSpan(rowCount, span) {
+  const start = clamp(span.start, 0, rowCount);
+  const end = clamp(span.end, 0, rowCount);
+  return start <= end ? { start, end } : { start: end, end };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// ../core/dist/window-segment-tree.js
+var EMPTY_NODE = {
+  count: 0,
+  sum: 0,
+  mean: 0,
+  m2: 0,
+  min: void 0,
+  max: void 0
+};
+function segmentTreeAggregateValues(partition, expr) {
+  if (typeof expr.fn !== "object" || expr.distinct === true)
+    return void 0;
+  if ((expr.over.frame?.exclude ?? "no-others") !== "no-others")
+    return void 0;
+  const op = expr.fn.aggregate;
+  if (!isSegmentAggregate(op))
+    return void 0;
+  const tree = new SegmentTree(partition.map((row) => leafNode(row, expr, op)));
+  return partition.map((_row, index) => aggregateValue(op, tree.query(frameSpan(partition, index, expr))));
+}
+function isSegmentAggregate(op) {
+  switch (op) {
+    case "count":
+    case "sum":
+    case "avg":
+    case "min":
+    case "max":
+    case "var_samp":
+    case "var_pop":
+    case "stddev_samp":
+    case "stddev_pop":
+      return true;
+    default:
+      return false;
+  }
+}
+function leafNode(windowRow, expr, op) {
+  if (!filterRow(expr, windowRow.row))
+    return EMPTY_NODE;
+  const value = aggregateInputValue2(expr, windowRow);
+  if (op === "count")
+    return value === null ? EMPTY_NODE : { ...EMPTY_NODE, count: 1 };
+  if (value === null)
+    return EMPTY_NODE;
+  if (op === "min" || op === "max")
+    return { ...EMPTY_NODE, count: 1, min: value, max: value };
+  const numeric = numericValue2(op, value);
+  return { count: 1, sum: numeric, mean: numeric, m2: 0, min: void 0, max: void 0 };
+}
+function aggregateInputValue2(expr, windowRow) {
+  const arg = expr.args[0];
+  if (arg === void 0)
+    return 1;
+  return evaluate(arg, windowRow.row);
+}
+function aggregateValue(op, node) {
+  switch (op) {
+    case "count":
+      return node.count;
+    case "sum":
+      return node.count === 0 ? null : node.sum;
+    case "avg":
+      return node.count === 0 ? null : node.sum / node.count;
+    case "min":
+      return node.min ?? null;
+    case "max":
+      return node.max ?? null;
+    case "var_samp":
+      return node.count <= 1 ? null : variance(node) / (node.count - 1);
+    case "var_pop":
+      return node.count === 0 ? null : variance(node) / node.count;
+    case "stddev_samp":
+      return node.count <= 1 ? null : Math.sqrt(variance(node) / (node.count - 1));
+    case "stddev_pop":
+      return node.count === 0 ? null : Math.sqrt(variance(node) / node.count);
+    default:
+      throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", `Unsupported segment aggregate ${op}`);
+  }
+}
+function variance(node) {
+  return Math.max(0, node.m2);
+}
+function numericValue2(op, value) {
+  return numericAggregateValue(op, value);
+}
+var SegmentTree = class {
+  size;
+  nodes;
+  constructor(leaves) {
+    let size = 1;
+    while (size < leaves.length)
+      size *= 2;
+    this.size = size;
+    this.nodes = Array.from({ length: size * 2 }, () => EMPTY_NODE);
+    for (let index = 0; index < leaves.length; index += 1) {
+      this.nodes[size + index] = leaves[index] ?? EMPTY_NODE;
+    }
+    for (let index = size - 1; index > 0; index -= 1) {
+      this.nodes[index] = mergeNodes(this.nodes[index * 2] ?? EMPTY_NODE, this.nodes[index * 2 + 1] ?? EMPTY_NODE);
+    }
+  }
+  query(span) {
+    let left = span.start + this.size;
+    let right = span.end + this.size;
+    let leftNode = EMPTY_NODE;
+    let rightNode = EMPTY_NODE;
+    while (left < right) {
+      if (left % 2 === 1) {
+        leftNode = mergeNodes(leftNode, this.nodes[left] ?? EMPTY_NODE);
+        left += 1;
+      }
+      if (right % 2 === 1) {
+        right -= 1;
+        rightNode = mergeNodes(this.nodes[right] ?? EMPTY_NODE, rightNode);
+      }
+      left = Math.floor(left / 2);
+      right = Math.floor(right / 2);
+    }
+    return mergeNodes(leftNode, rightNode);
+  }
+};
+function mergeNodes(left, right) {
+  if (left.count === 0)
+    return right;
+  if (right.count === 0)
+    return left;
+  const count = left.count + right.count;
+  const delta = right.mean - left.mean;
+  return {
+    count,
+    sum: left.sum + right.sum,
+    mean: left.mean + delta * right.count / count,
+    m2: left.m2 + right.m2 + delta * delta * (left.count * right.count) / count,
+    min: mergeOrderValue(left.min, right.min, "min"),
+    max: mergeOrderValue(left.max, right.max, "max")
+  };
+}
+function mergeOrderValue(left, right, op) {
+  if (left === void 0)
+    return right;
+  if (right === void 0)
+    return left;
+  const comparison = compareScalar2(left, right);
+  return op === "min" ? comparison <= 0 ? left : right : comparison >= 0 ? left : right;
+}
+function compareScalar2(left, right) {
+  return compareAggregateScalars(left, right);
+}
+
+// ../core/dist/window-backend.js
+function applyWindowsToRows(inputRows, windows, options = {}) {
+  const rows = inputRows.map((row) => ({ ...row }));
+  options.enforceBufferedRows?.(rows.length);
+  if (options.estimateMemoryBytes !== void 0) {
+    options.enforceMemoryBytes?.(options.estimateMemoryBytes(rows));
+  }
+  for (const group of windowSortGroups(windows)) {
+    const sorted = partitionRows(rows, group.sortExpr);
+    sortWindowRows(sorted, group.sortExpr.over.orderBy);
+    for (const { alias, expr } of group.items) {
+      const windowRows = windowRowsForExpr(sorted, expr, group.sortExpr);
+      const spans = partitionSpans(windowRows);
+      const values = evaluateWindowRows(rows.length, windowRows, spans, expr, options);
+      for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        if (row !== void 0)
+          row[alias] = values[index] ?? null;
+      }
+    }
+  }
+  return rows;
+}
+function applyWindowsToRuns(inputRuns, windows, options = {}) {
+  const outputRuns = inputRuns.map((run) => run.map((row) => ({ ...row })));
+  for (const group of windowSortGroups(windows)) {
+    const sortedRuns = outputRuns.map((run, runIndex) => partitionRows(run, group.sortExpr).map((item, rowIndex) => ({
+      ...item,
+      runIndex,
+      rowIndex
+    })));
+    for (const run of sortedRuns)
+      sortWindowRows(run, group.sortExpr.over.orderBy);
+    for (const partition of mergeWindowPartitions(sortedRuns, group.sortExpr)) {
+      options.enforceWindowPartitionRows?.(partition.length);
+      if (options.estimateMemoryBytes !== void 0) {
+        options.enforceMemoryBytes?.(options.estimateMemoryBytes(partition.map((item) => item.row)));
+      }
+      for (const { alias, expr } of group.items) {
+        const windowRows = windowRowsForExpr(partition, expr, group.sortExpr);
+        const values = evaluatePartition(windowRows, expr);
+        for (let index = 0; index < windowRows.length; index += 1) {
+          const item = windowRows[index];
+          if (item === void 0)
+            continue;
+          const row = outputRuns[item.runIndex]?.[item.rowIndex];
+          if (row !== void 0)
+            row[alias] = values[index] ?? null;
+        }
+      }
+    }
+  }
+  return outputRuns;
+}
+function windowSortGroups(windows) {
+  return compatibleWindowSortGroups(Object.entries(windows).map(([alias, expr]) => ({ alias, expr })));
+}
+function windowRowsForExpr(sorted, expr, sortExpr) {
+  const orderKeyLength = expr.over.orderBy.length;
+  const projected = sorted.map((item) => ({
+    ...item,
+    orderKey: item.orderKey.slice(0, orderKeyLength)
+  }));
+  if (orderKeyLength === sortExpr.over.orderBy.length)
+    return projected;
+  stabilizePrefixPeers(projected);
+  return projected;
+}
+function* mergeWindowPartitions(runs, sortExpr) {
+  const cursors = runs.map(() => 0);
+  let current = [];
+  let currentPartitionKey;
+  while (true) {
+    let bestRun = -1;
+    let best;
+    for (let runIndex = 0; runIndex < runs.length; runIndex += 1) {
+      const candidate = runs[runIndex]?.[cursors[runIndex] ?? 0];
+      if (candidate === void 0)
+        continue;
+      if (best === void 0 || compareWindowRows(candidate, best, sortExpr.over.orderBy) < 0) {
+        best = candidate;
+        bestRun = runIndex;
+      }
+    }
+    if (best === void 0 || bestRun === -1)
+      break;
+    cursors[bestRun] = (cursors[bestRun] ?? 0) + 1;
+    const partitionKey = stableKey(best.partitionKey);
+    if (currentPartitionKey !== void 0 && partitionKey !== currentPartitionKey) {
+      yield current;
+      current = [];
+    }
+    currentPartitionKey = partitionKey;
+    current.push(best);
+  }
+  if (current.length > 0)
+    yield current;
+}
+function stabilizePrefixPeers(rows) {
+  let start = 0;
+  while (start < rows.length) {
+    const current = rows[start];
+    if (current === void 0)
+      break;
+    const partitionKey = stableKey(current.partitionKey);
+    const orderKey = stableKey(current.orderKey);
+    let end = start + 1;
+    while (end < rows.length && stableKey(rows[end]?.partitionKey ?? []) === partitionKey && stableKey(rows[end]?.orderKey ?? []) === orderKey) {
+      end += 1;
+    }
+    if (end - start > 1) {
+      rows.slice(start, end).sort((left, right) => left.originalIndex - right.originalIndex).forEach((row, index) => {
+        rows[start + index] = row;
+      });
+    }
+    start = end;
+  }
+}
+function evaluateWindowRows(rowCount, sorted, spans, expr, options) {
+  const output = new Array(rowCount).fill(null);
+  for (const span of spans) {
+    const partition = sorted.slice(span.start, span.end);
+    options.enforceWindowPartitionRows?.(partition.length);
+    const values = evaluatePartition(partition, expr);
+    for (let index = 0; index < partition.length; index += 1) {
+      const item = partition[index];
+      if (item !== void 0)
+        output[item.originalIndex] = values[index] ?? null;
+    }
+  }
+  return output;
+}
+function evaluatePartition(partition, expr) {
+  const rows = partition.map((item) => item.row);
+  const fn = normalizedWindowName(expr.fn);
+  if (isAggregateWindow(expr.fn)) {
+    const segmentValues = segmentTreeAggregateValues(partition, expr);
+    if (segmentValues !== void 0)
+      return segmentValues;
+    return partition.map((_item, index) => aggregateWindowValue(frameRows(partition, index, expr), expr));
+  }
+  switch (fn) {
+    case "row_number":
+      return rows.map((_row, index) => index + 1);
+    case "rank":
+      return rankValues(rows, expr, false);
+    case "dense_rank":
+      return rankValues(rows, expr, true);
+    case "percent_rank": {
+      if (rows.length <= 1)
+        return rows.map(() => 0);
+      const ranks = rankValues(rows, expr, false);
+      return ranks.map((rank) => (rank - 1) / (rows.length - 1));
+    }
+    case "cume_dist":
+      return cumeDistValues(rows, expr);
+    case "ntile":
+      return ntileValues(rows, expr);
+    case "lag":
+      return offsetValues(rows, expr, -1);
+    case "lead":
+      return offsetValues(rows, expr, 1);
+    case "first_value":
+      return partition.map((_item, index) => {
+        const row = firstFrameValue(frameRows(partition, index, expr), expr);
+        return row === void 0 ? null : evaluate(valueArg(expr), row);
+      });
+    case "last_value":
+      return partition.map((_item, index) => {
+        const row = lastFrameValue(frameRows(partition, index, expr), expr);
+        return row === void 0 ? null : evaluate(valueArg(expr), row);
+      });
+    case "nth_value":
+      return nthValue(partition, expr);
+    default:
+      throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", `Unsupported window function ${fn}`, {
+        function: fn
+      });
+  }
+}
+function rankValues(rows, expr, dense) {
+  const sorted = partitionRows(rows, expr);
+  const ranks = [];
+  let rank = 1;
+  let denseRank = 1;
+  for (let index = 0; index < sorted.length; index += 1) {
+    const previous = sorted[index - 1];
+    const current = sorted[index];
+    if (index > 0 && previous !== void 0 && current !== void 0 && !samePeer(previous, current)) {
+      rank = index + 1;
+      denseRank += 1;
+    }
+    ranks.push(dense ? denseRank : rank);
+  }
+  return ranks;
+}
+function cumeDistValues(rows, expr) {
+  const sorted = partitionRows(rows, expr);
+  const out = [];
+  for (let index = 0; index < sorted.length; index += 1) {
+    let endPeer = index;
+    while (endPeer + 1 < sorted.length) {
+      const current = sorted[index];
+      const next = sorted[endPeer + 1];
+      if (current === void 0 || next === void 0 || !samePeer(current, next))
+        break;
+      endPeer += 1;
+    }
+    out.push((endPeer + 1) / rows.length);
+  }
+  return out;
+}
+function ntileValues(rows, expr) {
+  const bucketCount = numericArg(expr, 0, 0);
+  if (!Number.isInteger(bucketCount) || bucketCount <= 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "ntile requires a positive integer bucket count");
+  }
+  const base = Math.floor(rows.length / bucketCount);
+  const extra = rows.length % bucketCount;
+  return rows.map((_row, index) => index < (base + 1) * extra ? Math.floor(index / (base + 1)) + 1 : extra + Math.floor((index - (base + 1) * extra) / base) + 1);
+}
+function offsetValues(rows, expr, direction) {
+  const offset2 = expr.args.length >= 2 ? numericArg(expr, 1, 1) : 1;
+  if (!Number.isInteger(offset2) || offset2 < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "lag/lead offset must be a non-negative integer");
+  }
+  if (expr.ignoreNulls === true)
+    return offsetIgnoringNulls(rows, expr, direction, offset2);
+  return rows.map((row, index) => {
+    const target = rows[index + direction * offset2];
+    if (target === void 0)
+      return expr.args[2] === void 0 ? null : evaluate(expr.args[2], row);
+    return evaluate(valueArg(expr), target);
+  });
+}
+function offsetIgnoringNulls(rows, expr, direction, offset2) {
+  const arg = valueArg(expr);
+  return rows.map((row, index) => {
+    if (offset2 === 0)
+      return evaluate(arg, row);
+    let remaining = offset2;
+    for (let targetIndex = index + direction; targetIndex >= 0 && targetIndex < rows.length; targetIndex += direction) {
+      const target = rows[targetIndex];
+      if (target === void 0 || evaluate(arg, target) === null)
+        continue;
+      remaining -= 1;
+      if (remaining === 0)
+        return evaluate(arg, target);
+    }
+    return expr.args[2] === void 0 ? null : evaluate(expr.args[2], row);
+  });
+}
+function nthValue(partition, expr) {
+  const nth = numericArg(expr, 1, 1);
+  if (!Number.isInteger(nth) || nth <= 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "nth_value requires a positive integer position");
+  }
+  return partition.map((_item, index) => {
+    const rows = frameValueRows(frameRows(partition, index, expr), expr);
+    const target = rows[nth - 1];
+    return target === void 0 ? null : evaluate(valueArg(expr), target);
+  });
+}
+function valueArg(expr) {
+  const arg = expr.args[0];
+  if (arg === void 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${normalizedWindowName(expr.fn)} requires a value argument`);
+  }
+  return arg;
+}
+function numericArg(expr, index, fallback) {
+  const arg = expr.args[index];
+  if (arg === void 0)
+    return fallback;
+  if (arg.kind !== "literal" || typeof arg.value !== "number") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${normalizedWindowName(expr.fn)} argument must be numeric literal`);
+  }
+  return arg.value;
+}
+function firstFrameValue(rows, expr) {
+  return frameValueRows(rows, expr)[0];
+}
+function lastFrameValue(rows, expr) {
+  const values = frameValueRows(rows, expr);
+  return values[values.length - 1];
+}
+function frameValueRows(rows, expr) {
+  if (expr.ignoreNulls !== true)
+    return [...rows];
+  const arg = valueArg(expr);
+  return rows.filter((row) => evaluate(arg, row) !== null);
+}
+
+export { applyWindowsToRows, applyWindowsToRuns, evaluateWindowRows, windowRowsForExpr, windowSortGroups };