@vaultgradient/pipequery-lang 1.12.2 → 1.13.0

package/dist/engine/index.js

@@ -1,2093 +1,18 @@
-// src/engine/types.ts
-var AGGREGATE_NAMES = /* @__PURE__ */ new Set([
-  "sum",
-  "avg",
-  "min",
-  "max",
-  "count",
-  "median",
-  "stddev",
-  "var",
-  "percentile",
-  "skew",
-  "kurt",
-  "vwap",
-  "wavg",
-  "drawdown",
-  "pct",
-  "sharpe",
-  "calmar",
-  "sortino",
-  "info_ratio",
-  "distinct_count",
-  "sum_abs",
-  "abs_sum",
-  "first_value",
-  "last_value"
-]);
-var TWO_ARG_AGGREGATES = /* @__PURE__ */ new Set([
-  "percentile",
-  "vwap",
-  "wavg",
-  "info_ratio"
-]);
-var DataWeaveError = class extends Error {
-  position;
-  line;
-  column;
-  constructor(message, position, line, column) {
-    super(message);
-    this.name = "DataWeaveError";
-    this.position = position;
-    this.line = line;
-    this.column = column;
-  }
-};
-var LexerError = class extends DataWeaveError {
-  constructor(message, position, line, column) {
-    super(message, position, line, column);
-    this.name = "LexerError";
-  }
-};
-var ParseError = class extends DataWeaveError {
-  constructor(message, position, line, column) {
-    super(message, position, line, column);
-    this.name = "ParseError";
-  }
-};
-var RuntimeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RuntimeError";
-  }
-};
-
-// src/engine/lexer.ts
-var KEYWORDS = {
-  as: "AS",
-  asc: "ASC",
-  desc: "DESC",
-  true: "BOOLEAN",
-  false: "BOOLEAN",
-  null: "NULL"
-};
-function tokenize(source) {
-  const tokens = [];
-  let pos = 0;
-  let line = 1;
-  let column = 1;
-  function advance() {
-    const ch = source[pos];
-    pos++;
-    if (ch === "\n") {
-      line++;
-      column = 1;
-    } else {
-      column++;
-    }
-    return ch;
-  }
-  function peek() {
-    return source[pos];
-  }
-  function peekNext() {
-    return source[pos + 1];
-  }
-  function addToken(type, value, startPos, startLine, startCol) {
-    tokens.push({ type, value, position: startPos, line: startLine, column: startCol });
-  }
-  function error(msg) {
-    throw new LexerError(msg, pos, line, column);
-  }
-  while (pos < source.length) {
-    const startPos = pos;
-    const startLine = line;
-    const startCol = column;
-    const ch = peek();
-    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
-      advance();
-      continue;
-    }
-    if (ch === "|") {
-      advance();
-      addToken("PIPE", "|", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "(") {
-      advance();
-      addToken("LPAREN", "(", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === ")") {
-      advance();
-      addToken("RPAREN", ")", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === ",") {
-      advance();
-      addToken("COMMA", ",", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === ".") {
-      advance();
-      addToken("DOT", ".", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "+") {
-      advance();
-      addToken("PLUS", "+", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "-") {
-      advance();
-      addToken("MINUS", "-", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "*") {
-      advance();
-      addToken("STAR", "*", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "/") {
-      advance();
-      addToken("SLASH", "/", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "%") {
-      advance();
-      addToken("MOD", "%", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === ">" && peekNext() === "=") {
-      advance();
-      advance();
-      addToken("GTE", ">=", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === ">") {
-      advance();
-      addToken("GT", ">", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "<" && peekNext() === "=") {
-      advance();
-      advance();
-      addToken("LTE", "<=", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "<") {
-      advance();
-      addToken("LT", "<", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "=" && peekNext() === "=") {
-      advance();
-      advance();
-      addToken("EQ", "==", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "!" && peekNext() === "=") {
-      advance();
-      advance();
-      addToken("NEQ", "!=", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "!") {
-      advance();
-      addToken("NOT", "!", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "&" && peekNext() === "&") {
-      advance();
-      advance();
-      addToken("AND", "&&", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === "|" && peekNext() === "|") {
-      advance();
-      advance();
-      addToken("OR", "||", startPos, startLine, startCol);
-      continue;
-    }
-    if (ch >= "0" && ch <= "9") {
-      const start = pos;
-      while (pos < source.length && peek() >= "0" && peek() <= "9") advance();
-      if (pos < source.length && peek() === "." && pos + 1 < source.length && source[pos + 1] >= "0" && source[pos + 1] <= "9") {
-        advance();
-        while (pos < source.length && peek() >= "0" && peek() <= "9") advance();
-      }
-      addToken("NUMBER", source.slice(start, pos), startPos, startLine, startCol);
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      advance();
-      const start = pos;
-      let value = "";
-      while (pos < source.length && peek() !== quote) {
-        if (peek() === "\\" && pos + 1 < source.length) {
-          advance();
-          const escaped = advance();
-          if (escaped === "n") value += "\n";
-          else if (escaped === "t") value += "	";
-          else value += escaped;
-        } else {
-          value += advance();
-        }
-      }
-      if (pos >= source.length) {
-        error(`Unterminated string starting at line ${startLine}, column ${startCol}`);
-      }
-      advance();
-      void start;
-      addToken("STRING", value, startPos, startLine, startCol);
-      continue;
-    }
-    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_") {
-      const start = pos;
-      while (pos < source.length && (peek() >= "a" && peek() <= "z" || peek() >= "A" && peek() <= "Z" || peek() >= "0" && peek() <= "9" || peek() === "_")) {
-        advance();
-      }
-      const word = source.slice(start, pos);
-      const keywordType = KEYWORDS[word];
-      if (keywordType) {
-        addToken(keywordType, word, startPos, startLine, startCol);
-      } else {
-        addToken("IDENTIFIER", word, startPos, startLine, startCol);
-      }
-      continue;
-    }
-    error(`Unexpected character '${ch}'`);
-  }
-  addToken("EOF", "", pos, line, column);
-  return tokens;
-}
-
-// src/engine/parser.ts
-function parse(tokens) {
-  let pos = 0;
-  function peek() {
-    return tokens[pos];
-  }
-  function advance() {
-    const token = tokens[pos];
-    pos++;
-    return token;
-  }
-  function expect(type, context) {
-    const token = peek();
-    if (token.type !== type) {
-      const ctx = context ? ` ${context}` : "";
-      throw new ParseError(
-        `Expected ${type} but found ${token.type} ('${token.value}')${ctx}`,
-        token.position,
-        token.line,
-        token.column
-      );
-    }
-    return advance();
-  }
-  function match(type) {
-    if (peek().type === type) {
-      advance();
-      return true;
-    }
-    return false;
-  }
-  function parseExpression() {
-    let expr = parseOrExpr();
-    if (peek().type === "AS") {
-      advance();
-      const nameToken = expect("IDENTIFIER", 'after "as"');
-      expr = { kind: "AliasExpr", expression: expr, alias: nameToken.value };
-    }
-    return expr;
-  }
-  function parseOrExpr() {
-    let left = parseAndExpr();
-    while (peek().type === "OR") {
-      advance();
-      const right = parseAndExpr();
-      left = { kind: "BinaryExpr", operator: "||", left, right };
-    }
-    return left;
-  }
-  function parseAndExpr() {
-    let left = parseEqualityExpr();
-    while (peek().type === "AND") {
-      advance();
-      const right = parseEqualityExpr();
-      left = { kind: "BinaryExpr", operator: "&&", left, right };
-    }
-    return left;
-  }
-  function parseEqualityExpr() {
-    let left = parseComparisonExpr();
-    while (peek().type === "EQ" || peek().type === "NEQ") {
-      const op = advance().value;
-      const right = parseComparisonExpr();
-      left = { kind: "BinaryExpr", operator: op, left, right };
-    }
-    return left;
-  }
-  function parseComparisonExpr() {
-    let left = parseAdditiveExpr();
-    while (peek().type === "GT" || peek().type === "GTE" || peek().type === "LT" || peek().type === "LTE") {
-      const op = advance().value;
-      const right = parseAdditiveExpr();
-      left = { kind: "BinaryExpr", operator: op, left, right };
-    }
-    return left;
-  }
-  function parseAdditiveExpr() {
-    let left = parseMultiplicativeExpr();
-    while (peek().type === "PLUS" || peek().type === "MINUS") {
-      const op = advance().value;
-      const right = parseMultiplicativeExpr();
-      left = { kind: "BinaryExpr", operator: op, left, right };
-    }
-    return left;
-  }
-  function parseMultiplicativeExpr() {
-    let left = parseUnaryExpr();
-    while (peek().type === "STAR" || peek().type === "SLASH" || peek().type === "MOD") {
-      const op = advance().value;
-      const right = parseUnaryExpr();
-      left = { kind: "BinaryExpr", operator: op, left, right };
-    }
-    return left;
-  }
-  function parseUnaryExpr() {
-    if (peek().type === "NOT") {
-      advance();
-      const operand = parseUnaryExpr();
-      return { kind: "UnaryExpr", operator: "!", operand };
-    }
-    if (peek().type === "MINUS") {
-      advance();
-      const operand = parseUnaryExpr();
-      return { kind: "UnaryExpr", operator: "-", operand };
-    }
-    return parsePrimaryExpr();
-  }
-  function parsePrimaryExpr() {
-    const token = peek();
-    if (token.type === "NUMBER") {
-      advance();
-      return { kind: "NumberLiteral", value: Number(token.value) };
-    }
-    if (token.type === "STRING") {
-      advance();
-      return { kind: "StringLiteral", value: token.value };
-    }
-    if (token.type === "BOOLEAN") {
-      advance();
-      return { kind: "BooleanLiteral", value: token.value === "true" };
-    }
-    if (token.type === "NULL") {
-      advance();
-      return { kind: "NullLiteral" };
-    }
-    if (token.type === "IDENTIFIER") {
-      advance();
-      const name = token.value;
-      if (peek().type === "LPAREN") {
-        advance();
-        const args = [];
-        if (peek().type !== "RPAREN") {
-          args.push(parseExpression());
-          while (match("COMMA")) {
-            args.push(parseExpression());
-          }
-        }
-        expect("RPAREN", "after function arguments");
-        return { kind: "FunctionCall", name, args };
-      }
-      const path = [name];
-      while (peek().type === "DOT") {
-        advance();
-        const next = expect("IDENTIFIER", 'after "."');
-        path.push(next.value);
-      }
-      return { kind: "FieldAccess", path };
-    }
-    if (token.type === "LPAREN") {
-      advance();
-      const expr = parseExpression();
-      expect("RPAREN", "after grouped expression");
-      return expr;
-    }
-    throw new ParseError(
-      `Unexpected token ${token.type} ('${token.value}')`,
-      token.position,
-      token.line,
-      token.column
-    );
-  }
-  function isAggregateExpression(expr) {
-    if (expr.kind === "AliasExpr") return isAggregateExpression(expr.expression);
-    if (expr.kind === "FunctionCall") return AGGREGATE_NAMES.has(expr.name);
-    return false;
-  }
-  function parseOperation() {
-    const nameToken = expect("IDENTIFIER", 'after "|"');
-    const name = nameToken.value;
-    expect("LPAREN", `after "${name}"`);
-    let op;
-    switch (name) {
-      case "where": {
-        const condition = parseExpression();
-        op = { kind: "WhereOp", condition };
-        break;
-      }
-      case "select": {
-        const fields = [];
-        if (peek().type !== "RPAREN") {
-          fields.push(parseExpression());
-          while (match("COMMA")) {
-            fields.push(parseExpression());
-          }
-        }
-        op = { kind: "SelectOp", fields };
-        break;
-      }
-      case "sort": {
-        const criteria = [];
-        if (peek().type !== "RPAREN") {
-          const expr = parseOrExpr();
-          let direction = "asc";
-          if (peek().type === "ASC") {
-            advance();
-            direction = "asc";
-          } else if (peek().type === "DESC") {
-            advance();
-            direction = "desc";
-          }
-          criteria.push({ expression: expr, direction });
-          while (match("COMMA")) {
-            const e = parseOrExpr();
-            let d = "asc";
-            if (peek().type === "ASC") {
-              advance();
-              d = "asc";
-            } else if (peek().type === "DESC") {
-              advance();
-              d = "desc";
-            }
-            criteria.push({ expression: e, direction: d });
-          }
-        }
-        op = { kind: "SortOp", criteria };
-        break;
-      }
-      case "groupBy": {
-        const keys = [];
-        if (peek().type !== "RPAREN") {
-          keys.push(parseOrExpr());
-          while (match("COMMA")) {
-            keys.push(parseOrExpr());
-          }
-        }
-        op = { kind: "GroupByOp", keys };
-        break;
-      }
-      case "join": {
-        const rightToken = expect("IDENTIFIER", "for join source");
-        const right = rightToken.value;
-        expect("COMMA", "after join source");
-        const condition = parseExpression();
-        op = { kind: "JoinOp", right, condition };
-        break;
-      }
-      case "first": {
-        const numToken = expect("NUMBER", "for first count");
-        op = { kind: "FirstOp", count: Number(numToken.value) };
-        break;
-      }
-      case "last": {
-        const numToken = expect("NUMBER", "for last count");
-        op = { kind: "LastOp", count: Number(numToken.value) };
-        break;
-      }
-      case "distinct": {
-        const fields = [];
-        if (peek().type !== "RPAREN") {
-          fields.push(parseOrExpr());
-          while (match("COMMA")) {
-            fields.push(parseOrExpr());
-          }
-        }
-        op = { kind: "DistinctOp", fields: fields.length > 0 ? fields : void 0 };
-        break;
-      }
-      case "flatten": {
-        let field;
-        if (peek().type !== "RPAREN") {
-          field = parseOrExpr();
-        }
-        op = { kind: "FlattenOp", field };
-        break;
-      }
-      case "transpose": {
-        let headerField;
-        if (peek().type !== "RPAREN") {
-          headerField = parseOrExpr();
-        }
-        op = { kind: "TransposeOp", headerField };
-        break;
-      }
-      case "rollup": {
-        const keys = [];
-        const aggregates = [];
-        let seenAggregate = false;
-        if (peek().type !== "RPAREN") {
-          const expr = parseExpression();
-          if (isAggregateExpression(expr)) {
-            seenAggregate = true;
-            aggregates.push(expr);
-          } else {
-            keys.push(expr);
-          }
-          while (match("COMMA")) {
-            const e = parseExpression();
-            if (isAggregateExpression(e)) {
-              seenAggregate = true;
-              aggregates.push(e);
-            } else if (seenAggregate) {
-              const t = peek();
-              throw new ParseError(
-                "rollup: group keys must come before aggregate expressions",
-                t.position,
-                t.line,
-                t.column
-              );
-            } else {
-              keys.push(e);
-            }
-          }
-        }
-        if (aggregates.length === 0) {
-          const t = peek();
-          throw new ParseError(
-            "rollup: at least one aggregate expression is required",
-            t.position,
-            t.line,
-            t.column
-          );
-        }
-        op = { kind: "RollupOp", keys, aggregates };
-        break;
-      }
-      case "pivot": {
-        const pivotField = parseOrExpr();
-        expect("COMMA", "after pivot field");
-        const aggregates = [];
-        aggregates.push(parseExpression());
-        while (match("COMMA")) {
-          aggregates.push(parseExpression());
-        }
-        op = { kind: "PivotOp", pivotField, aggregates };
-        break;
-      }
-      case "map": {
-        const fields = [];
-        if (peek().type !== "RPAREN") {
-          fields.push(parseExpression());
-          while (match("COMMA")) {
-            fields.push(parseExpression());
-          }
-        }
-        op = { kind: "MapOp", fields };
-        break;
-      }
-      case "reduce": {
-        const initial = parseExpression();
-        expect("COMMA", "after reduce initial value");
-        const accumulator = parseExpression();
-        op = { kind: "ReduceOp", initial, accumulator };
-        break;
-      }
-      default: {
-        if (AGGREGATE_NAMES.has(name)) {
-          if (TWO_ARG_AGGREGATES.has(name)) {
-            const args = [];
-            args.push(parseOrExpr());
-            expect("COMMA", `after first argument of ${name}`);
-            args.push(parseOrExpr());
-            op = { kind: "AggregateOp", function: name, args };
-          } else {
-            let field;
-            if (peek().type !== "RPAREN") {
-              field = parseOrExpr();
-            }
-            op = { kind: "AggregateOp", function: name, field };
-          }
-          break;
-        }
-        throw new ParseError(
-          `Unknown operation "${name}"`,
-          nameToken.position,
-          nameToken.line,
-          nameToken.column
-        );
-      }
-    }
-    expect("RPAREN", `after ${name} arguments`);
-    return op;
-  }
-  function parsePipeline() {
-    const sourceToken = expect("IDENTIFIER", "at start of pipeline");
-    const operations = [];
-    while (peek().type === "PIPE") {
-      advance();
-      operations.push(parseOperation());
-    }
-    if (peek().type !== "EOF") {
-      const t = peek();
-      throw new ParseError(
-        `Unexpected token ${t.type} ('${t.value}') after pipeline`,
-        t.position,
-        t.line,
-        t.column
-      );
-    }
-    return { kind: "Pipeline", source: sourceToken.value, operations };
-  }
-  return parsePipeline();
-}
-
-// src/engine/runtime.ts
-var accessorCache = /* @__PURE__ */ new Map();
-function getFieldAccessor(path) {
-  const key = path.join(".");
-  let fn = accessorCache.get(key);
-  if (fn) return fn;
-  if (path.length === 1) {
-    const field = path[0];
-    fn = (obj) => obj[field];
-  } else {
-    const segments = [...path];
-    fn = (obj) => {
-      let val = obj;
-      for (const segment of segments) {
-        if (val == null) return void 0;
-        val = val[segment];
-      }
-      return val;
-    };
-  }
-  accessorCache.set(key, fn);
-  return fn;
-}
-function compareValues(a, b) {
-  if (a === b) return 0;
-  if (a == null && b == null) return 0;
-  if (a == null) return -1;
-  if (b == null) return 1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  return String(a).localeCompare(String(b));
-}
-function groupByFn(data, keyFns) {
-  const groups = /* @__PURE__ */ new Map();
-  if (keyFns.length === 1) {
-    const { fn, name } = keyFns[0];
-    for (const row of data) {
-      const val = fn(row);
-      const groupKey = String(val);
-      let group = groups.get(groupKey);
-      if (!group) {
-        group = { keys: { [name]: val }, rows: [] };
-        groups.set(groupKey, group);
-      }
-      group.rows.push(row);
-    }
-  } else {
-    for (const row of data) {
-      const keys = {};
-      let groupKey = "";
-      for (let i = 0; i < keyFns.length; i++) {
-        const { fn, name } = keyFns[i];
-        const val = fn(row);
-        keys[name] = val;
-        groupKey += (i > 0 ? "\0" : "") + String(val);
-      }
-      let group = groups.get(groupKey);
-      if (!group) {
-        group = { keys, rows: [] };
-        groups.set(groupKey, group);
-      }
-      group.rows.push(row);
-    }
-  }
-  return Array.from(groups.values());
-}
-function nestedLoopJoin(left, right, conditionFn) {
-  const result = [];
-  for (const l of left) {
-    for (const r of right) {
-      const combined = { ...l, ...r };
-      if (conditionFn(combined)) {
-        result.push(combined);
-      }
-    }
-  }
-  return result;
-}
-function hashJoin(left, right, leftKeyFn, rightKeyFn) {
-  const hashMap = /* @__PURE__ */ new Map();
-  for (const r of right) {
-    const key = rightKeyFn(r);
-    let bucket = hashMap.get(key);
-    if (!bucket) {
-      bucket = [];
-      hashMap.set(key, bucket);
-    }
-    bucket.push(r);
-  }
-  const result = [];
-  for (const l of left) {
-    const matches = hashMap.get(leftKeyFn(l));
-    if (matches) {
-      for (const r of matches) {
-        result.push({ ...l, ...r });
-      }
-    }
-  }
-  return result;
-}
-function distinctFn(data, keyFn) {
-  const seen = /* @__PURE__ */ new Set();
-  return data.filter((row) => {
-    const key = keyFn ? keyFn(row) : JSON.stringify(row);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-function transposeFn(data, headerFn, headerFieldName) {
-  if (data.length === 0) return [];
-  const colNames = data.map(
-    (row, i) => headerFn ? String(headerFn(row)) : `col_${i}`
-  );
-  const allFields = /* @__PURE__ */ new Set();
-  for (const row of data) {
-    for (const key of Object.keys(row)) {
-      if (key !== "_group" && key !== headerFieldName) {
-        allFields.add(key);
-      }
-    }
-  }
-  const results = [];
-  for (const field of allFields) {
-    const row = { _field: field };
-    for (let i = 0; i < data.length; i++) {
-      row[colNames[i]] = data[i][field] ?? null;
-    }
-    results.push(row);
-  }
-  return results;
-}
-function rollupFn(data, keyFns, aggFns) {
-  const results = [];
-  const numKeys = keyFns.length;
-  for (let level = 0; level <= numKeys; level++) {
-    const activeKeys = keyFns.slice(0, numKeys - level);
-    const groups = groupByFn(data, activeKeys);
-    for (const group of groups) {
-      const row = {};
-      for (const { name } of activeKeys) {
-        row[name] = group.keys[name];
-      }
-      for (let i = numKeys - level; i < numKeys; i++) {
-        row[keyFns[i].name] = null;
-      }
-      const groupedRow = { ...row, _group: group.rows };
-      for (const { fn, name } of aggFns) {
-        row[name] = fn(groupedRow);
-      }
-      row._rollupLevel = level;
-      results.push(row);
-    }
-  }
-  return results;
-}
-function defaultForAggregate(name) {
-  if (name === "min" || name === "max") return null;
-  return 0;
-}
-function pivotFlatFn(data, pivotFn, aggCompilers, singleAggregate) {
-  const pivotGroups = /* @__PURE__ */ new Map();
-  for (const row of data) {
-    const pivotVal = String(pivotFn(row));
-    if (!pivotGroups.has(pivotVal)) pivotGroups.set(pivotVal, []);
-    pivotGroups.get(pivotVal).push(row);
-  }
-  const result = {};
-  for (const [pivotVal, groupRows] of pivotGroups) {
-    const syntheticRow = { _group: groupRows };
-    const safeName = pivotVal.replace(/\s+/g, "_");
-    for (const { fn, name } of aggCompilers) {
-      const colName = singleAggregate ? safeName : `${name}_${safeName}`;
-      result[colName] = fn(syntheticRow);
-    }
-  }
-  return [result];
-}
-function pivotGroupedFn(data, pivotFn, aggCompilers, singleAggregate) {
-  const allPivotValues = /* @__PURE__ */ new Set();
-  for (const groupRow of data) {
-    const groupData = groupRow._group;
-    for (const row of groupData) {
-      allPivotValues.add(String(pivotFn(row)));
-    }
-  }
-  return data.map((groupRow) => {
-    const groupData = groupRow._group;
-    const result = {};
-    for (const key of Object.keys(groupRow)) {
-      if (key !== "_group") result[key] = groupRow[key];
-    }
-    const subGroups = /* @__PURE__ */ new Map();
-    for (const row of groupData) {
-      const pivotVal = String(pivotFn(row));
-      if (!subGroups.has(pivotVal)) subGroups.set(pivotVal, []);
-      subGroups.get(pivotVal).push(row);
-    }
-    for (const pivotVal of allPivotValues) {
-      const subGroupRows = subGroups.get(pivotVal) || [];
-      const syntheticRow = { _group: subGroupRows };
-      const safeName = pivotVal.replace(/\s+/g, "_");
-      for (const { fn, name } of aggCompilers) {
-        const colName = singleAggregate ? safeName : `${name}_${safeName}`;
-        result[colName] = subGroupRows.length > 0 ? fn(syntheticRow) : defaultForAggregate(name);
-      }
-    }
-    return result;
-  });
-}
-function computeWindowValues(data, windowDefs) {
-  const n = data.length;
-  const results = Array.from({ length: n }, () => ({}));
-  for (const def of windowDefs) {
-    switch (def.name) {
-      case "row_number":
-      case "running_count":
-        for (let i = 0; i < n; i++) results[i][def.id] = i + 1;
-        break;
-      case "running_sum": {
-        let acc = 0;
-        for (let i = 0; i < n; i++) {
-          acc += Number(def.fieldFn(data[i]));
-          results[i][def.id] = acc;
-        }
-        break;
-      }
-      case "running_avg": {
-        let acc = 0;
-        for (let i = 0; i < n; i++) {
-          acc += Number(def.fieldFn(data[i]));
-          results[i][def.id] = acc / (i + 1);
-        }
-        break;
-      }
-      case "running_min": {
-        let min = Infinity;
-        for (let i = 0; i < n; i++) {
-          const val = Number(def.fieldFn(data[i]));
-          if (val < min) min = val;
-          results[i][def.id] = min;
-        }
-        break;
-      }
-      case "running_max": {
-        let max = -Infinity;
-        for (let i = 0; i < n; i++) {
-          const val = Number(def.fieldFn(data[i]));
-          if (val > max) max = val;
-          results[i][def.id] = max;
-        }
-        break;
-      }
-      case "lag": {
-        const offset = def.offset;
-        for (let i = 0; i < n; i++) {
-          results[i][def.id] = i >= offset ? def.fieldFn(data[i - offset]) : null;
-        }
-        break;
-      }
-      case "lead": {
-        const offset = def.offset;
-        for (let i = 0; i < n; i++) {
-          results[i][def.id] = i + offset < n ? def.fieldFn(data[i + offset]) : null;
-        }
-        break;
-      }
-    }
-  }
-  return results;
-}
-
-// src/engine/compiler.ts
-function computeMedian(values) {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-}
-function computePercentile(values, p) {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const idx = p / 100 * (sorted.length - 1);
-  const lo = Math.floor(idx);
-  const hi = Math.ceil(idx);
-  if (lo === hi) return sorted[lo];
-  return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
-}
-function computeVariance(values) {
-  if (values.length === 0) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / values.length;
-  return values.reduce((acc, v) => acc + (v - mean) ** 2, 0) / values.length;
-}
-function computeStddev(values) {
-  return Math.sqrt(computeVariance(values));
-}
-function computeSkew(values) {
-  const n = values.length;
-  if (n < 3) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / n;
-  const sd = computeStddev(values);
-  if (sd === 0) return 0;
-  return values.reduce((acc, v) => acc + ((v - mean) / sd) ** 3, 0) / n;
-}
-function computeKurt(values) {
-  const n = values.length;
-  if (n < 4) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / n;
-  const sd = computeStddev(values);
-  if (sd === 0) return 0;
-  return values.reduce((acc, v) => acc + ((v - mean) / sd) ** 4, 0) / n - 3;
-}
-function computeDrawdown(values) {
-  if (values.length === 0) return 0;
-  let peak = values[0];
-  let maxDd = 0;
-  for (const v of values) {
-    if (v > peak) peak = v;
-    const dd = peak === 0 ? 0 : (v - peak) / peak;
-    if (dd < maxDd) maxDd = dd;
-  }
-  return maxDd;
-}
-function computeDownsideDeviation(values, target = 0) {
-  if (values.length === 0) return 0;
-  const downside = values.filter((v) => v < target).map((v) => (v - target) ** 2);
-  if (downside.length === 0) return 0;
-  return Math.sqrt(downside.reduce((a, b) => a + b, 0) / values.length);
-}
-var WINDOW_FUNCTION_NAMES = /* @__PURE__ */ new Set([
-  "running_sum",
-  "running_avg",
-  "running_count",
-  "running_min",
-  "running_max",
-  "row_number",
-  "lag",
-  "lead"
-]);
-var windowIdCounter = 0;
-function compileExpression(expr, grouped = false) {
-  switch (expr.kind) {
-    case "NumberLiteral": {
-      const v = expr.value;
-      return () => v;
-    }
-    case "StringLiteral": {
-      const v = expr.value;
-      return () => v;
-    }
-    case "BooleanLiteral": {
-      const v = expr.value;
-      return () => v;
-    }
-    case "NullLiteral":
-      return () => null;
-    case "FieldAccess": {
-      const accessor = getFieldAccessor(expr.path);
-      return accessor;
-    }
-    case "BinaryExpr": {
-      const leftFn = compileExpression(expr.left, grouped);
-      const rightFn = compileExpression(expr.right, grouped);
-      const op = expr.operator;
-      switch (op) {
-        case ">":
-          return (row) => leftFn(row) > rightFn(row);
-        case ">=":
-          return (row) => leftFn(row) >= rightFn(row);
-        case "<":
-          return (row) => leftFn(row) < rightFn(row);
-        case "<=":
-          return (row) => leftFn(row) <= rightFn(row);
-        case "==":
-          return (row) => leftFn(row) === rightFn(row);
-        case "!=":
-          return (row) => leftFn(row) !== rightFn(row);
-        case "&&":
-          return (row) => leftFn(row) && rightFn(row);
-        case "||":
-          return (row) => leftFn(row) || rightFn(row);
-        case "+":
-          return (row) => leftFn(row) + rightFn(row);
-        case "-":
-          return (row) => leftFn(row) - rightFn(row);
-        case "*":
-          return (row) => leftFn(row) * rightFn(row);
-        case "/":
-          return (row) => leftFn(row) / rightFn(row);
-        case "%":
-          return (row) => leftFn(row) % rightFn(row);
-      }
-      break;
-    }
-    case "UnaryExpr": {
-      const operandFn = compileExpression(expr.operand, grouped);
-      if (expr.operator === "!") return (row) => !operandFn(row);
-      return (row) => -operandFn(row);
-    }
-    case "FunctionCall":
-      return compileFunctionCall(expr, grouped);
-    case "AliasExpr":
-      return compileExpression(expr.expression, grouped);
-  }
-  throw new RuntimeError(`Unknown expression kind: ${expr.kind}`);
-}
-function compileFunctionCall(expr, grouped) {
-  const { name, args } = expr;
-  if (grouped && AGGREGATE_NAMES.has(name)) {
-    return compileGroupAggregate(name, args);
-  }
-  if (WINDOW_FUNCTION_NAMES.has(name)) {
-    const id = `_w${windowIdCounter++}`;
-    const fieldFn = args.length > 0 ? compileExpression(args[0], false) : void 0;
-    const offset = args.length > 1 ? args[1].value || 1 : 1;
-    const fn = ((row) => {
-      const ctx = row._windowCtx;
-      return ctx?.[id];
-    });
-    fn._windowDef = { id, name, fieldFn, offset };
-    return fn;
-  }
-  switch (name) {
-    case "if": {
-      if (args.length < 2 || args.length > 3) {
-        throw new RuntimeError(`if() expects 2 or 3 arguments, got ${args.length}`);
-      }
-      const condFn = compileExpression(args[0], grouped);
-      const thenFn = compileExpression(args[1], grouped);
-      const elseFn = args.length === 3 ? compileExpression(args[2], grouped) : () => null;
-      return (row) => condFn(row) ? thenFn(row) : elseFn(row);
-    }
-    case "coalesce": {
-      const fns = args.map((a) => compileExpression(a, grouped));
-      return (row) => {
-        for (const fn of fns) {
-          const val = fn(row);
-          if (val != null) return val;
-        }
-        return null;
-      };
-    }
-    case "lower": {
-      const fn = compileExpression(args[0], grouped);
-      return (row) => String(fn(row)).toLowerCase();
-    }
-    case "upper": {
-      const fn = compileExpression(args[0], grouped);
-      return (row) => String(fn(row)).toUpperCase();
-    }
-    case "len": {
-      const fn = compileExpression(args[0], grouped);
-      return (row) => {
-        const val = fn(row);
-        if (Array.isArray(val)) return val.length;
-        if (typeof val === "string") return val.length;
-        return 0;
-      };
-    }
-    case "abs": {
-      const fn = compileExpression(args[0], grouped);
-      return (row) => Math.abs(fn(row));
-    }
-    case "round": {
-      const fn = compileExpression(args[0], grouped);
-      const precFn = args.length > 1 ? compileExpression(args[1], grouped) : () => 0;
-      return (row) => {
-        const val = fn(row);
-        const prec = precFn(row);
-        const factor = Math.pow(10, prec);
-        return Math.round(val * factor) / factor;
-      };
-    }
-    case "concat": {
-      const fns = args.map((a) => compileExpression(a, grouped));
-      return (row) => fns.map((fn) => String(fn(row))).join("");
-    }
-    // ── String functions ────────────────────────────────────
-    case "contains": {
-      if (args.length !== 2) throw new RuntimeError(`contains() expects 2 arguments, got ${args.length}`);
-      const strFn = compileExpression(args[0], grouped);
-      const searchFn = compileExpression(args[1], grouped);
-      return (row) => String(strFn(row)).includes(String(searchFn(row)));
-    }
-    case "startsWith": {
-      if (args.length !== 2) throw new RuntimeError(`startsWith() expects 2 arguments, got ${args.length}`);
-      const strFn = compileExpression(args[0], grouped);
-      const prefixFn = compileExpression(args[1], grouped);
-      return (row) => String(strFn(row)).startsWith(String(prefixFn(row)));
-    }
-    case "endsWith": {
-      if (args.length !== 2) throw new RuntimeError(`endsWith() expects 2 arguments, got ${args.length}`);
-      const strFn = compileExpression(args[0], grouped);
-      const suffixFn = compileExpression(args[1], grouped);
-      return (row) => String(strFn(row)).endsWith(String(suffixFn(row)));
-    }
-    case "trim": {
-      if (args.length !== 1) throw new RuntimeError(`trim() expects 1 argument, got ${args.length}`);
-      const fn = compileExpression(args[0], grouped);
-      return (row) => String(fn(row)).trim();
-    }
-    case "substring": {
-      if (args.length < 2 || args.length > 3) throw new RuntimeError(`substring() expects 2 or 3 arguments, got ${args.length}`);
-      const strFn = compileExpression(args[0], grouped);
-      const startFn = compileExpression(args[1], grouped);
-      const lenFn = args.length === 3 ? compileExpression(args[2], grouped) : void 0;
-      return (row) => {
-        const s = String(strFn(row));
-        const start = Number(startFn(row));
-        if (lenFn) {
-          return s.substring(start, start + Number(lenFn(row)));
-        }
-        return s.substring(start);
-      };
-    }
-    case "replace": {
-      if (args.length !== 3) throw new RuntimeError(`replace() expects 3 arguments, got ${args.length}`);
-      const strFn = compileExpression(args[0], grouped);
-      const searchFn = compileExpression(args[1], grouped);
-      const replaceFn = compileExpression(args[2], grouped);
-      return (row) => String(strFn(row)).replaceAll(String(searchFn(row)), String(replaceFn(row)));
-    }
-    // Non-grouped aggregates used as functions return NaN or undefined — they're
-    // only meaningful as pipeline-level AggregateOps or in grouped selects
-    default:
-      throw new RuntimeError(`Unknown function: ${name}`);
-  }
-}
-function compileGroupAggregate(name, args) {
-  const fieldFn = args.length > 0 ? compileExpression(args[0], false) : void 0;
-  const secondFn = args.length > 1 ? compileExpression(args[1], false) : void 0;
-  const extractValues = (row) => row._group.map((r) => Number(fieldFn(r)));
-  switch (name) {
-    // ── Core ───────────────────────────────────────────────
-    case "sum":
-      return (row) => {
-        const group = row._group;
-        return group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
-      };
-    case "avg":
-      return (row) => {
-        const group = row._group;
-        if (group.length === 0) return 0;
-        const total = group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
-        return total / group.length;
-      };
-    case "min":
-      return (row) => {
-        const group = row._group;
-        if (group.length === 0) return null;
-        return group.reduce((min, r) => {
-          const val = fieldFn(r);
-          return val < min ? val : min;
-        }, fieldFn(group[0]));
-      };
-    case "max":
-      return (row) => {
-        const group = row._group;
-        if (group.length === 0) return null;
-        return group.reduce((max, r) => {
-          const val = fieldFn(r);
-          return val > max ? val : max;
-        }, fieldFn(group[0]));
-      };
-    case "count":
-      return (row) => {
-        const group = row._group;
-        return group.length;
-      };
-    // ── Statistical ───────────────────────────────────────
-    case "median":
-      return (row) => computeMedian(extractValues(row));
-    case "stddev":
-      return (row) => computeStddev(extractValues(row));
-    case "var":
-      return (row) => computeVariance(extractValues(row));
-    case "percentile":
-      return (row) => computePercentile(extractValues(row), Number(secondFn(row)));
-    case "skew":
-      return (row) => computeSkew(extractValues(row));
-    case "kurt":
-      return (row) => computeKurt(extractValues(row));
-    // ── Finance ───────────────────────────────────────────
-    case "vwap":
-      return (row) => {
-        const group = row._group;
-        let sumPV = 0, sumV = 0;
-        for (const r of group) {
-          const p = Number(fieldFn(r));
-          const v = Number(secondFn(r));
-          sumPV += p * v;
-          sumV += v;
-        }
-        return sumV === 0 ? 0 : sumPV / sumV;
-      };
-    case "wavg":
-      return (row) => {
-        const group = row._group;
-        let sumWV = 0, sumW = 0;
-        for (const r of group) {
-          const val = Number(fieldFn(r));
-          const w = Number(secondFn(r));
-          sumWV += val * w;
-          sumW += w;
-        }
-        return sumW === 0 ? 0 : sumWV / sumW;
-      };
-    case "drawdown":
-      return (row) => computeDrawdown(extractValues(row));
-    // ── Ratios ────────────────────────────────────────────
-    case "pct":
-      return (row) => {
-        const group = row._group;
-        return group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
-      };
-    case "sharpe":
-      return (row) => {
-        const vals = extractValues(row);
-        if (vals.length === 0) return 0;
-        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
-        const sd = computeStddev(vals);
-        return sd === 0 ? 0 : mean / sd;
-      };
-    case "calmar":
-      return (row) => {
-        const vals = extractValues(row);
-        if (vals.length === 0) return 0;
-        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
-        const dd = Math.abs(computeDrawdown(vals));
-        return dd === 0 ? 0 : mean / dd;
-      };
-    case "sortino":
-      return (row) => {
-        const vals = extractValues(row);
-        if (vals.length === 0) return 0;
-        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
-        const dsd = computeDownsideDeviation(vals, 0);
-        return dsd === 0 ? 0 : mean / dsd;
-      };
-    case "info_ratio":
-      return (row) => {
-        const group = row._group;
-        const excess = group.map((r) => Number(fieldFn(r)) - Number(secondFn(r)));
-        if (excess.length === 0) return 0;
-        const mean = excess.reduce((a, b) => a + b, 0) / excess.length;
-        const sd = computeStddev(excess);
-        return sd === 0 ? 0 : mean / sd;
-      };
-    // ── Counting ──────────────────────────────────────────
-    case "distinct_count":
-      return (row) => {
-        const group = row._group;
-        return new Set(group.map((r) => fieldFn(r))).size;
-      };
-    case "sum_abs":
-      return (row) => {
-        const group = row._group;
-        return group.reduce((acc, r) => acc + Math.abs(Number(fieldFn(r))), 0);
-      };
-    case "abs_sum":
-      return (row) => {
-        const group = row._group;
-        return Math.abs(group.reduce((acc, r) => acc + Number(fieldFn(r)), 0));
-      };
-    // ── Range ─────────────────────────────────────────────
-    case "first_value":
-      return (row) => {
-        const group = row._group;
-        return group.length > 0 ? fieldFn(group[0]) : null;
-      };
-    case "last_value":
-      return (row) => {
-        const group = row._group;
-        return group.length > 0 ? fieldFn(group[group.length - 1]) : null;
-      };
-    default:
-      throw new RuntimeError(`Unknown aggregate function: ${name}`);
-  }
-}
-function resolveFieldName(expr) {
-  switch (expr.kind) {
-    case "AliasExpr":
-      return expr.alias;
-    case "FieldAccess":
-      return expr.path[expr.path.length - 1];
-    case "FunctionCall":
-      return expr.name;
-    default:
-      return "value";
-  }
-}
-function compileOperation(op, isGrouped) {
-  switch (op.kind) {
-    case "WhereOp": {
-      const condFn = compileExpression(op.condition);
-      return {
-        fn: (data) => data.filter((row) => condFn(row)),
-        producesGrouped: false
-      };
-    }
-    case "SelectOp":
-      return compileSelectOp(op, isGrouped);
-    case "SortOp": {
-      const criteria = op.criteria.map((c) => ({
-        fn: compileExpression(c.expression),
-        dir: c.direction === "desc" ? -1 : 1
-      }));
-      return {
-        fn: (data) => {
-          return [...data].sort((a, b) => {
-            for (const { fn, dir } of criteria) {
-              const cmp = compareValues(fn(a), fn(b));
-              if (cmp !== 0) return cmp * dir;
-            }
-            return 0;
-          });
-        },
-        producesGrouped: false
-      };
-    }
-    case "GroupByOp": {
-      const keyFns = op.keys.map((k) => {
-        const fn = compileExpression(k);
-        const name = k.kind === "FieldAccess" ? k.path[k.path.length - 1] : "key";
-        return { fn, name };
-      });
-      return {
-        fn: (data) => {
-          const groups = groupByFn(data, keyFns);
-          return groups.map((g) => ({ ...g.keys, _group: g.rows }));
-        },
-        producesGrouped: true
-      };
-    }
-    case "JoinOp": {
-      const rightSource = op.right;
-      if (op.condition.kind === "BinaryExpr" && op.condition.operator === "==" && op.condition.left.kind === "FieldAccess" && op.condition.right.kind === "FieldAccess") {
-        const leftKeyFn = compileExpression(op.condition.left);
-        const rightKeyFn = compileExpression(op.condition.right);
-        return {
-          fn: (data, context) => {
-            const rightData = context[rightSource];
-            if (!rightData) {
-              throw new RuntimeError(`Join source "${rightSource}" not found in context`);
-            }
-            return hashJoin(data, rightData, leftKeyFn, rightKeyFn);
-          },
-          producesGrouped: false
-        };
-      }
-      const condFn = compileExpression(op.condition);
-      return {
-        fn: (data, context) => {
-          const rightData = context[rightSource];
-          if (!rightData) {
-            throw new RuntimeError(`Join source "${rightSource}" not found in context`);
-          }
-          return nestedLoopJoin(data, rightData, condFn);
-        },
-        producesGrouped: false
-      };
-    }
-    case "FirstOp": {
-      const count = op.count;
-      return {
-        fn: (data) => data.slice(0, count),
-        producesGrouped: false
-      };
-    }
-    case "LastOp": {
-      const count = op.count;
-      return {
-        fn: (data) => data.slice(-count),
-        producesGrouped: false
-      };
-    }
-    case "DistinctOp": {
-      const keyFn = op.fields ? (() => {
-        const fns = op.fields.map((f) => compileExpression(f));
-        return (row) => JSON.stringify(fns.map((fn) => fn(row)));
-      })() : void 0;
-      return {
-        fn: (data) => distinctFn(data, keyFn),
-        producesGrouped: false
-      };
-    }
-    case "FlattenOp": {
-      if (op.field) {
-        const fieldFn = compileExpression(op.field);
-        return {
-          fn: (data) => data.flatMap((row) => {
-            const val = fieldFn(row);
-            return Array.isArray(val) ? val : [val];
-          }),
-          producesGrouped: false
-        };
-      }
-      return {
-        fn: (data) => data.flat(),
-        producesGrouped: false
-      };
-    }
-    case "TransposeOp": {
-      const headerFn = op.headerField ? compileExpression(op.headerField) : void 0;
-      const headerFieldName = op.headerField ? resolveFieldName(op.headerField) : void 0;
-      return {
-        fn: (data) => transposeFn(data, headerFn, headerFieldName),
-        producesGrouped: false
-      };
-    }
-    case "RollupOp": {
-      const keyFns = op.keys.map((k) => {
-        const fn = compileExpression(k);
-        const name = resolveFieldName(k);
-        return { fn, name };
-      });
-      const aggFns = op.aggregates.map((a) => {
-        const fn = compileExpression(a, true);
-        const name = resolveFieldName(a);
-        return { fn, name };
-      });
-      const pctCols = /* @__PURE__ */ new Set();
-      for (const a of op.aggregates) {
-        const expr = a.kind === "AliasExpr" ? a.expression : a;
-        if (expr.kind === "FunctionCall" && expr.name === "pct") {
-          pctCols.add(resolveFieldName(a));
-        }
-      }
-      return {
-        fn: (data) => {
-          const results = rollupFn(data, keyFns, aggFns);
-          if (pctCols.size > 0) {
-            const numKeys = keyFns.length;
-            const grandRow = results.find((r) => r._rollupLevel === numKeys);
-            for (const col of pctCols) {
-              const total = Number(grandRow?.[col]) || 1;
-              for (const row of results) {
-                row[col] = Number(row[col]) / total * 100;
-              }
-            }
-            if (pctCols.size === aggFns.length) {
-              return results.filter((r) => r._rollupLevel !== numKeys);
-            }
-          }
-          return results;
-        },
-        producesGrouped: false
-      };
-    }
-    case "PivotOp": {
-      const pivotFn = compileExpression(op.pivotField);
-      const aggCompilers = op.aggregates.map((a) => ({
-        fn: compileExpression(a, true),
-        // grouped = true
-        name: resolveFieldName(a)
-      }));
-      const singleAggregate = aggCompilers.length === 1;
-      return {
-        fn: (data) => {
-          if (isGrouped) {
-            return pivotGroupedFn(data, pivotFn, aggCompilers, singleAggregate);
-          }
-          return pivotFlatFn(data, pivotFn, aggCompilers, singleAggregate);
-        },
-        producesGrouped: false
-      };
-    }
-    case "MapOp": {
-      const fieldCompilers = op.fields.map((field) => {
-        const name = resolveFieldName(field);
-        const fn = compileExpression(field, isGrouped);
-        return { name, fn };
-      });
-      return {
-        fn: (data) => data.map((row) => {
-          const result = { ...row };
-          for (const { name, fn } of fieldCompilers) {
-            result[name] = fn(row);
-          }
-          return result;
-        }),
-        producesGrouped: isGrouped
-      };
-    }
-    case "ReduceOp": {
-      const initialFn = compileExpression(op.initial);
-      const accFn = compileExpression(op.accumulator);
-      return {
-        fn: (data) => {
-          let acc = initialFn({});
-          for (const row of data) {
-            acc = accFn({ ...row, _acc: acc });
-          }
-          return acc;
-        },
-        producesGrouped: false
-      };
-    }
-    case "AggregateOp": {
-      const argFns = op.args?.map((a) => compileExpression(a));
-      const primaryFn = argFns ? argFns[0] : op.field ? compileExpression(op.field) : void 0;
-      const secondFn = argFns ? argFns[1] : void 0;
-      const aggName = op.function;
-      return {
-        fn: (data) => {
-          const vals = () => data.map((row) => Number(primaryFn(row)));
-          switch (aggName) {
-            // ── Core ──────────────────────────────────────
-            case "count":
-              return data.length;
-            case "sum":
-              return data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
-            case "avg": {
-              if (data.length === 0) return 0;
-              const total = data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
-              return total / data.length;
-            }
-            case "min":
-              return data.reduce((min, row) => {
-                const val = primaryFn(row);
-                return val < min ? val : min;
-              }, primaryFn(data[0]));
-            case "max":
-              return data.reduce((max, row) => {
-                const val = primaryFn(row);
-                return val > max ? val : max;
-              }, primaryFn(data[0]));
-            // ── Statistical ───────────────────────────────
-            case "median":
-              return computeMedian(vals());
-            case "stddev":
-              return computeStddev(vals());
-            case "var":
-              return computeVariance(vals());
-            case "percentile":
-              return computePercentile(vals(), Number(secondFn(data[0])));
-            case "skew":
-              return computeSkew(vals());
-            case "kurt":
-              return computeKurt(vals());
-            // ── Finance ───────────────────────────────────
-            case "vwap": {
-              let sumPV = 0, sumV = 0;
-              for (const row of data) {
-                const p = Number(primaryFn(row));
-                const v = Number(secondFn(row));
-                sumPV += p * v;
-                sumV += v;
-              }
-              return sumV === 0 ? 0 : sumPV / sumV;
-            }
-            case "wavg": {
-              let sumWV = 0, sumW = 0;
-              for (const row of data) {
-                const val = Number(primaryFn(row));
-                const w = Number(secondFn(row));
-                sumWV += val * w;
-                sumW += w;
-              }
-              return sumW === 0 ? 0 : sumWV / sumW;
-            }
-            case "drawdown":
-              return computeDrawdown(vals());
-            // ── Ratios ────────────────────────────────────
-            case "pct": {
-              return data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
-            }
-            case "sharpe": {
-              const v = vals();
-              if (v.length === 0) return 0;
-              const mean = v.reduce((a, b) => a + b, 0) / v.length;
-              const sd = computeStddev(v);
-              return sd === 0 ? 0 : mean / sd;
-            }
-            case "calmar": {
-              const v = vals();
-              if (v.length === 0) return 0;
-              const mean = v.reduce((a, b) => a + b, 0) / v.length;
-              const dd = Math.abs(computeDrawdown(v));
-              return dd === 0 ? 0 : mean / dd;
-            }
-            case "sortino": {
-              const v = vals();
-              if (v.length === 0) return 0;
-              const mean = v.reduce((a, b) => a + b, 0) / v.length;
-              const dsd = computeDownsideDeviation(v, 0);
-              return dsd === 0 ? 0 : mean / dsd;
-            }
-            case "info_ratio": {
-              const excess = data.map((row) => Number(primaryFn(row)) - Number(secondFn(row)));
-              if (excess.length === 0) return 0;
-              const mean = excess.reduce((a, b) => a + b, 0) / excess.length;
-              const sd = computeStddev(excess);
-              return sd === 0 ? 0 : mean / sd;
-            }
-            // ── Counting ──────────────────────────────────
-            case "distinct_count":
-              return new Set(data.map((row) => primaryFn(row))).size;
-            case "sum_abs":
-              return data.reduce((acc, row) => acc + Math.abs(Number(primaryFn(row))), 0);
-            case "abs_sum":
-              return Math.abs(data.reduce((acc, row) => acc + Number(primaryFn(row)), 0));
-            // ── Range ─────────────────────────────────────
-            case "first_value":
-              return data.length > 0 ? primaryFn(data[0]) : null;
-            case "last_value":
-              return data.length > 0 ? primaryFn(data[data.length - 1]) : null;
-          }
-        },
-        producesGrouped: false
-      };
-    }
-  }
-}
-function compileSelectOp(op, isGrouped) {
-  const fieldCompilers = op.fields.map((field) => {
-    const name = resolveFieldName(field);
-    const fn = compileExpression(field, isGrouped);
-    return { name, fn };
-  });
-  const windowDefs = [];
-  for (const { fn } of fieldCompilers) {
-    const wDef = fn._windowDef;
-    if (wDef) windowDefs.push(wDef);
-  }
-  if (windowDefs.length > 0) {
-    return {
-      fn: (data) => {
-        const windowValues = computeWindowValues(data, windowDefs);
-        return data.map((row, i) => {
-          const enrichedRow = { ...row, _windowCtx: windowValues[i] };
-          const result = {};
-          for (const { name, fn } of fieldCompilers) {
-            result[name] = fn(enrichedRow);
-          }
-          return result;
-        });
-      },
-      producesGrouped: false
-    };
-  }
-  return {
-    fn: (data) => {
-      return data.map((row) => {
-        const result = {};
-        for (const { name, fn } of fieldCompilers) {
-          result[name] = fn(row);
-        }
-        return result;
-      });
-    },
-    producesGrouped: false
-  };
-}
-function compile(ast, source) {
-  const compiledOps = [];
-  let isGrouped = false;
-  for (const op of ast.operations) {
-    const { fn, producesGrouped } = compileOperation(op, isGrouped);
-    compiledOps.push(fn);
-    isGrouped = producesGrouped;
-  }
-  const sourceName = ast.source;
-  const queryFn = (context) => {
-    const sourceData = context[sourceName];
-    if (!sourceData) {
-      throw new RuntimeError(`Source "${sourceName}" not found in context`);
-    }
-    if (!Array.isArray(sourceData)) {
-      throw new RuntimeError(`Source "${sourceName}" is not an array`);
-    }
-    let data = sourceData;
-    for (const opFn of compiledOps) {
-      if (!Array.isArray(data)) {
-        return data;
-      }
-      data = opFn(data, context);
-    }
-    return data;
-  };
-  const compiled = queryFn;
-  Object.defineProperty(compiled, "source", { value: source, writable: false });
-  Object.defineProperty(compiled, "ast", { value: ast, writable: false });
-  return compiled;
-}
-
-// src/engine/cache.ts
-var QueryCache = class {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
-  constructor(maxSize = 128) {
-    this.maxSize = maxSize;
-  }
-  get(key) {
-    const value = this.cache.get(key);
-    if (value) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-};
-
-// src/engine/live.ts
-var OPERATION_KEYWORDS = /* @__PURE__ */ new Set([
-  "where",
-  "select",
-  "sort",
-  "groupBy",
-  "join",
-  "first",
-  "last",
-  "distinct",
-  "map",
-  "reduce",
-  "rollup",
-  "pivot",
-  "flatten",
-  "transpose"
-]);
-function normalizeExpression(expression) {
-  const trimmed = expression.trimStart();
-  const match = trimmed.match(/^(\w+)\s*\(/);
-  if (match && OPERATION_KEYWORDS.has(match[1])) {
-    return `_data | ${trimmed}`;
-  }
-  return expression;
-}
-var LiveQuery = class {
-  _index;
-  _keyFields;
-  _sourceName;
-  _context;
-  _compiled;
-  _throttle;
-  _pendingTimer;
-  _executing;
-  _dirtyDuringExec;
-  _result;
-  _stats;
-  _subscribers;
-  _batchDepth;
-  _batchDirty;
-  _disposed;
-  constructor(data, expression, options) {
-    this._keyFields = Array.isArray(options.key) ? options.key : [options.key];
-    this._throttle = options.throttle ?? 0;
-    this._pendingTimer = null;
-    this._executing = false;
-    this._dirtyDuringExec = false;
-    this._subscribers = /* @__PURE__ */ new Set();
-    this._batchDepth = 0;
-    this._batchDirty = false;
-    this._disposed = false;
-    this._result = void 0;
-    this._stats = {
-      patchMs: 0,
-      executionMs: 0,
-      totalMs: 0,
-      rowCount: 0,
-      resultCount: 0,
-      patchCount: 0,
-      tick: 0
-    };
-    if (Array.isArray(data)) {
-      this._sourceName = "_data";
-      this._compiled = compile2(normalizeExpression(expression));
-      this._context = { _data: [] };
-      this._index = /* @__PURE__ */ new Map();
-      this._buildIndex(data);
-    } else {
-      this._sourceName = options.source ?? Object.keys(data)[0];
-      this._compiled = compile2(expression);
-      this._context = { ...data };
-      this._index = /* @__PURE__ */ new Map();
-      const sourceData = data[this._sourceName];
-      if (Array.isArray(sourceData)) {
-        this._buildIndex(sourceData);
-      }
-    }
-    this._executeSync();
-  }
-  // ── Public getters ─────────────────────────────────────────────
-  get result() {
-    return this._result;
-  }
-  get stats() {
-    return { ...this._stats };
-  }
-  get size() {
-    return this._index.size;
-  }
-  // ── Subscription ───────────────────────────────────────────────
-  subscribe(fn) {
-    this._guardDisposed();
-    this._subscribers.add(fn);
-    return () => {
-      this._subscribers.delete(fn);
-    };
-  }
-  // ── Patching ───────────────────────────────────────────────────
-  patch(changed, removals) {
-    this._guardDisposed();
-    const patchStart = performance.now();
-    for (const row of changed) {
-      const mapKey = this._rowKey(row);
-      this._index.set(mapKey, row);
-    }
-    if (removals) {
-      for (const removal of removals) {
-        const mapKey = this._removalKey(removal);
-        this._index.delete(mapKey);
-      }
-    }
-    this._stats.patchMs = performance.now() - patchStart;
-    this._stats.patchCount++;
-    if (this._batchDepth > 0) {
-      this._batchDirty = true;
-      return;
-    }
-    if (this._executing) {
-      this._dirtyDuringExec = true;
-      return;
-    }
-    this._scheduleExecution();
-  }
-  // ── Reset ──────────────────────────────────────────────────────
-  reset(data) {
-    this._guardDisposed();
-    this._index.clear();
-    this._buildIndex(data);
-    this._stats.patchMs = 0;
-    this._scheduleExecution();
-  }
-  // ── Query change ───────────────────────────────────────────────
-  setQuery(expression) {
-    this._guardDisposed();
-    const normalized = this._sourceName === "_data" ? normalizeExpression(expression) : expression;
-    this._compiled = compile2(normalized);
-    this._stats.patchMs = 0;
-    this._scheduleExecution();
-  }
-  // ── Batching ───────────────────────────────────────────────────
-  beginBatch() {
-    this._guardDisposed();
-    this._batchDepth++;
-  }
-  endBatch() {
-    this._guardDisposed();
-    if (this._batchDepth <= 0) {
-      throw new RuntimeError("LiveQuery: endBatch() called without matching beginBatch()");
-    }
-    this._batchDepth--;
-    if (this._batchDepth === 0 && this._batchDirty) {
-      this._batchDirty = false;
-      this._scheduleExecution();
-    }
-  }
-  // ── Cleanup ────────────────────────────────────────────────────
-  dispose() {
-    if (this._pendingTimer !== null) {
-      clearTimeout(this._pendingTimer);
-      this._pendingTimer = null;
-    }
-    this._subscribers.clear();
-    this._index.clear();
-    this._result = void 0;
-    this._disposed = true;
-  }
-  // ── Private: key helpers ───────────────────────────────────────
-  _rowKey(row) {
-    if (this._keyFields.length === 1) {
-      const val = row[this._keyFields[0]];
-      if (val == null) {
-        throw new RuntimeError(
-          `LiveQuery: row is missing key field "${this._keyFields[0]}"`
-        );
-      }
-      return String(val);
-    }
-    let key = "";
-    for (let i = 0; i < this._keyFields.length; i++) {
-      const val = row[this._keyFields[i]];
-      if (val == null) {
-        throw new RuntimeError(
-          `LiveQuery: row is missing key field "${this._keyFields[i]}"`
-        );
-      }
-      if (i > 0) key += "\0";
-      key += String(val);
-    }
-    return key;
-  }
-  _removalKey(removal) {
-    if (typeof removal === "string") {
-      return removal;
-    }
-    return removal.map(String).join("\0");
-  }
-  // ── Private: index ─────────────────────────────────────────────
-  _buildIndex(rows) {
-    for (const row of rows) {
-      const key = this._rowKey(row);
-      this._index.set(key, row);
-    }
-  }
-  // ── Private: execution scheduling ──────────────────────────────
-  _scheduleExecution() {
-    if (this._pendingTimer !== null) return;
-    if (this._throttle === 0) {
-      this._pendingTimer = setTimeout(() => this._onTimer(), 0);
-    } else {
-      this._pendingTimer = setTimeout(() => this._onTimer(), this._throttle);
-    }
-  }
-  _onTimer() {
-    this._pendingTimer = null;
-    if (this._disposed) return;
-    this._executeSync();
-    if (this._dirtyDuringExec) {
-      this._dirtyDuringExec = false;
-      this._scheduleExecution();
-    }
-  }
-  _executeSync() {
-    this._executing = true;
-    this._dirtyDuringExec = false;
-    const rows = Array.from(this._index.values());
-    this._context[this._sourceName] = rows;
-    const execStart = performance.now();
-    this._result = this._compiled(this._context);
-    const executionMs = performance.now() - execStart;
-    this._stats.executionMs = executionMs;
-    this._stats.totalMs = this._stats.patchMs + executionMs;
-    this._stats.rowCount = rows.length;
-    this._stats.resultCount = Array.isArray(this._result) ? this._result.length : this._result != null ? 1 : 0;
-    this._stats.tick++;
-    this._executing = false;
-    this._notify();
-  }
-  _notify() {
-    const result = this._result;
-    const stats = { ...this._stats };
-    for (const fn of this._subscribers) {
-      try {
-        fn(result, stats);
-      } catch (err) {
-        console.error("LiveQuery subscriber error:", err);
-      }
-    }
-  }
-  _guardDisposed() {
-    if (this._disposed) {
-      throw new RuntimeError("LiveQuery: instance has been disposed");
-    }
-  }
-};
-function liveQuery(data, expression, options) {
-  return new LiveQuery(data, expression, options);
-}
-
-// src/engine/index.ts
-var defaultCache = new QueryCache(128);
-var OPERATION_KEYWORDS2 = /* @__PURE__ */ new Set([
-  "where",
-  "select",
-  "sort",
-  "groupBy",
-  "join",
-  "first",
-  "last",
-  "distinct",
-  "map",
-  "reduce",
-  "rollup",
-  "pivot",
-  "flatten",
-  "transpose"
-]);
-function normalizeExpression2(expression) {
-  const trimmed = expression.trimStart();
-  const match = trimmed.match(/^(\w+)\s*\(/);
-  if (match && OPERATION_KEYWORDS2.has(match[1])) {
-    return `_data | ${trimmed}`;
-  }
-  return expression;
-}
-function compile2(expression, useCache = true) {
-  if (useCache) {
-    const cached = defaultCache.get(expression);
-    if (cached) return cached;
-  }
-  const tokens = tokenize(expression);
-  const ast = parse(tokens);
-  const fn = compile(ast, expression);
-  if (useCache) {
-    defaultCache.set(expression, fn);
-  }
-  return fn;
-}
-function query(context, expression) {
-  if (Array.isArray(context)) {
-    const normalized = normalizeExpression2(expression);
-    const fn2 = compile2(normalized);
-    return fn2({ _data: context });
-  }
-  const fn = compile2(expression);
-  return fn(context);
-}
-function parseQuery(expression) {
-  const tokens = tokenize(expression);
-  return parse(tokens);
-}
-function clearCache() {
-  defaultCache.clear();
-}
+import {
+  DataWeaveError,
+  LexerError,
+  LiveQuery,
+  ParseError,
+  RuntimeError,
+  clearCache,
+  compile,
+  compileAst,
+  liveQuery,
+  parseQuery,
+  printExpression,
+  printQuery,
+  query
+} from "../chunk-KNVFXND5.js";
 export {
   DataWeaveError,
   LexerError,
@@ -2095,8 +20,11 @@ export {
   ParseError,
   RuntimeError,
   clearCache,
-  compile2 as compile,
+  compile,
+  compileAst,
   liveQuery,
   parseQuery,
+  printExpression,
+  printQuery,
   query
 };