@vaultgradient/pipequery-lang 1.12.2 → 1.13.0

package/dist/builder/index.cjs

@@ -0,0 +1,926 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+var _chunkLWM2ZXGDcjs = require('../chunk-LWM2ZXGD.cjs');
+
+// src/builder/raw.ts
+var BuilderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BuilderError";
+  }
+};
+var WRAPPER = "_data | ";
+function relabel(fn2) {
+  try {
+    return fn2();
+  } catch (e) {
+    if (e instanceof Error && e.name === "Error" && e.message.startsWith("printQuery: ")) {
+      throw new BuilderError(e.message.slice("printQuery: ".length));
+    }
+    throw e;
+  }
+}
+function checkIdentifier(name, what) {
+  return relabel(() => _chunkLWM2ZXGDcjs.assertIdentifier.call(void 0, name, what));
+}
+function validateOperation(op) {
+  relabel(() => _chunkLWM2ZXGDcjs.printQuery.call(void 0, { kind: "Pipeline", source: "_data", operations: [op] }));
+}
+function validateSource(name) {
+  return checkIdentifier(name, "source name");
+}
+function parseOperations(raw, wrapperLength = 0, label, internalName) {
+  if (typeof raw !== "string") {
+    throw new BuilderError(`${label ? `${label}: ` : ""}expected a pipequery string but got ${typeof raw}`);
+  }
+  const shift = WRAPPER.length + wrapperLength;
+  try {
+    return _chunkLWM2ZXGDcjs.parseQuery.call(void 0, WRAPPER + raw).operations;
+  } catch (e) {
+    if (e instanceof _chunkLWM2ZXGDcjs.DataWeaveError) {
+      if (e.line === 1 && e.position >= shift) {
+        e.position -= shift;
+        e.column -= shift;
+      }
+      if (label) {
+        let message = e.message;
+        if (internalName) {
+          const method = _optionalChain([/^(\w+)\(\)/, 'access', _ => _.exec, 'call', _2 => _2(label), 'optionalAccess', _3 => _3[1]]);
+          message = method ? message.replace(new RegExp(`\\b${internalName}\\b`, "g"), method) : message.replace(new RegExp(`\\s*\\b${internalName} arguments`, "g"), " the expression");
+        }
+        e.message = `${label}: ${message}`;
+      }
+    }
+    throw e;
+  }
+}
+function parseSingleOp(name, raw, kind, prefix = "", label = `${name}()`) {
+  const ops = parseOperations(`${name}(${prefix}${raw})`, name.length + 1 + prefix.length, label, name);
+  if (ops.length !== 1 || ops[0].kind !== kind) {
+    throw new (0, _chunkLWM2ZXGDcjs.ParseError)(
+      `${label}: invalid argument ${JSON.stringify(raw)}: expected a single argument list`,
+      0,
+      1,
+      1
+    );
+  }
+  return ops[0];
+}
+function parseExprList(raw, label = "select()") {
+  return parseSingleOp("select", raw, "SelectOp", "", label).fields;
+}
+function parseOrExprList(raw, label = "groupBy()") {
+  return parseSingleOp("groupBy", raw, "GroupByOp", "", label).keys;
+}
+function parseSortCriteria(raw, label = "sort()") {
+  return parseSingleOp("sort", raw, "SortOp", "", label).criteria;
+}
+function parseFieldExpr(raw, label = "field") {
+  const keys = parseOrExprList(raw, label);
+  if (keys.length !== 1) {
+    throw new (0, _chunkLWM2ZXGDcjs.ParseError)(
+      `${label}: expected exactly one expression but got ${keys.length} in ${JSON.stringify(raw)}`,
+      0,
+      1,
+      1
+    );
+  }
+  return keys[0];
+}
+
+// src/builder/expr.ts
+var NODE = /* @__PURE__ */ Symbol.for("pipequery.builder.node");
+var SortKey = class {
+  constructor(expression, direction) {
+    this.expression = expression;
+    this.direction = direction;
+  }
+  
+  
+};
+function toAst(value, what = "operand") {
+  if (value instanceof Expr) return value[NODE];
+  switch (typeof value) {
+    case "string":
+      return { kind: "StringLiteral", value };
+    case "boolean":
+      return { kind: "BooleanLiteral", value };
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new BuilderError(`invalid ${what}: ${String(value)} is not a finite number`);
+      }
+      if (value < 0 || Object.is(value, -0)) {
+        return {
+          kind: "UnaryExpr",
+          operator: "-",
+          operand: { kind: "NumberLiteral", value: -value }
+        };
+      }
+      return { kind: "NumberLiteral", value };
+  }
+  if (value === null) return { kind: "NullLiteral" };
+  if (value instanceof SortKey) {
+    throw new BuilderError(`invalid ${what}: asc()/desc() keys are only valid in sort()`);
+  }
+  throw new BuilderError(
+    `invalid ${what}: expected an expression, string, number, boolean or null but got ${value === void 0 ? "undefined" : typeof value}`
+  );
+}
+function toFieldAst(value, what) {
+  if (typeof value === "string") return parseFieldExpr(value, what);
+  return toAst(value, what);
+}
+function fieldPath(path) {
+  if (typeof path !== "string" || path === "") {
+    throw new BuilderError("invalid field path: expected a non-empty string");
+  }
+  return path.split(".").map((seg) => checkIdentifier(seg, "field name"));
+}
+function bin(operator, left, right) {
+  return new Expr({ kind: "BinaryExpr", operator, left: toAst(left), right: toAst(right) });
+}
+var ARITY = {
+  if: [2, 3],
+  coalesce: [1, Infinity],
+  lower: [1, 1],
+  upper: [1, 1],
+  len: [1, 1],
+  abs: [1, 1],
+  round: [1, 2],
+  concat: [1, Infinity],
+  contains: [2, 2],
+  startsWith: [2, 2],
+  endsWith: [2, 2],
+  trim: [1, 1],
+  substring: [2, 3],
+  replace: [3, 3]
+};
+function scalarCall(name, args) {
+  const [min, max] = ARITY[name];
+  if (args.length < min || args.length > max) {
+    const expected = min === max ? `${min}` : max === Infinity ? `at least ${min}` : `${min} or ${max}`;
+    throw new BuilderError(`${name}() expects ${expected} argument(s), got ${args.length}`);
+  }
+  return new Expr({
+    kind: "FunctionCall",
+    name,
+    args: args.map((a, i) => toAst(a, `argument ${i + 1} of ${name}()`))
+  });
+}
+function trimArgs(args) {
+  let n = args.length;
+  while (n > 0 && args[n - 1] === void 0) n--;
+  return args.slice(0, n);
+}
+function isBooleanNode(node) {
+  switch (node.kind) {
+    case "BooleanLiteral":
+      return true;
+    case "UnaryExpr":
+      return node.operator === "!";
+    case "BinaryExpr":
+      if (["==", "!=", "<", "<=", ">", ">="].includes(node.operator)) return true;
+      return (node.operator === "&&" || node.operator === "||") && isBooleanNode(node.left) && isBooleanNode(node.right);
+    case "FunctionCall":
+      if (["contains", "startsWith", "endsWith"].includes(node.name)) return true;
+      return node.name === "if" && node.args.length === 3 && isBooleanNode(node.args[0]) && isBooleanNode(node.args[1]) && isBooleanNode(node.args[2]);
+    default:
+      return false;
+  }
+}
+function isOrNode(n) {
+  return n.kind === "FunctionCall" && n.name === "if" && n.args.length === 3 && n.args[0] === n.args[1];
+}
+function orNode(left, right) {
+  if (isBooleanNode(left)) {
+    return { kind: "FunctionCall", name: "if", args: [left, { kind: "BooleanLiteral", value: true }, right] };
+  }
+  if (isOrNode(left)) {
+    const [cond, , rest] = left.args;
+    return { kind: "FunctionCall", name: "if", args: [cond, cond, orNode(rest, right)] };
+  }
+  return { kind: "FunctionCall", name: "if", args: [left, left, right] };
+}
+var Expr = class _Expr {
+  
+  constructor(node) {
+    this[NODE] = node;
+  }
+  // comparison
+  gt(other) {
+    return bin(">", this, other);
+  }
+  gte(other) {
+    return bin(">=", this, other);
+  }
+  lt(other) {
+    return bin("<", this, other);
+  }
+  lte(other) {
+    return bin("<=", this, other);
+  }
+  eq(other) {
+    return bin("==", this, other);
+  }
+  ne(other) {
+    return bin("!=", this, other);
+  }
+  // logical
+  and(other) {
+    return bin("&&", this, other);
+  }
+  /**
+   * Logical or. The AST uses `if(a, true, b)` for proven boolean `a`, and
+   * `if(a, a, b)` otherwise: the lexer cannot parse `||` (it reads two PIPE tokens).
+   * Both forms have the engine's `a || b` value semantics and round-trip through
+   * `parseQuery`. In the latter, `a` is evaluated twice; expressions are pure.
+   *
+   * Unknown-valued chains stay linear by associating right: `a.or(b).or(c)`
+   * becomes `if(a, a, if(b, b, c))`.
+   */
+  or(other) {
+    return new _Expr(orNode(this[NODE], toAst(other)));
+  }
+  not() {
+    return new _Expr({ kind: "UnaryExpr", operator: "!", operand: this[NODE] });
+  }
+  // arithmetic
+  plus(other) {
+    return bin("+", this, other);
+  }
+  minus(other) {
+    return bin("-", this, other);
+  }
+  times(other) {
+    return bin("*", this, other);
+  }
+  div(other) {
+    return bin("/", this, other);
+  }
+  mod(other) {
+    return bin("%", this, other);
+  }
+  neg() {
+    return new _Expr({ kind: "UnaryExpr", operator: "-", operand: this[NODE] });
+  }
+  // scalar functions
+  lower() {
+    return scalarCall("lower", [this]);
+  }
+  upper() {
+    return scalarCall("upper", [this]);
+  }
+  len() {
+    return scalarCall("len", [this]);
+  }
+  abs() {
+    return scalarCall("abs", [this]);
+  }
+  round(precision) {
+    return scalarCall("round", trimArgs([this, precision]));
+  }
+  trim() {
+    return scalarCall("trim", [this]);
+  }
+  concat(...rest) {
+    return scalarCall("concat", [this, ...rest]);
+  }
+  coalesce(...rest) {
+    return scalarCall("coalesce", [this, ...rest]);
+  }
+  contains(search) {
+    return scalarCall("contains", [this, search]);
+  }
+  startsWith(prefix) {
+    return scalarCall("startsWith", [this, prefix]);
+  }
+  endsWith(suffix) {
+    return scalarCall("endsWith", [this, suffix]);
+  }
+  substring(start, length) {
+    return scalarCall("substring", trimArgs([this, start, length]));
+  }
+  replace(search, replacement) {
+    return scalarCall("replace", [this, search, replacement]);
+  }
+  // naming and ordering
+  /** `expr as name`. Re-aliasing replaces the previous alias. */
+  as(name) {
+    checkIdentifier(name, "alias");
+    const node = this[NODE];
+    return new _Expr({
+      kind: "AliasExpr",
+      expression: node.kind === "AliasExpr" ? node.expression : node,
+      alias: name
+    });
+  }
+  asc() {
+    return new SortKey(this[NODE], "asc");
+  }
+  desc() {
+    return new SortKey(this[NODE], "desc");
+  }
+  /** Extend a field path with names that collide with `Expr` methods: `o.customer.$('len')`. */
+  $(...segments) {
+    const node = this[NODE];
+    if (node.kind !== "FieldAccess") {
+      throw new BuilderError("$() can only extend a field access");
+    }
+    return fieldProxy([...node.path, ...segments.map((s) => checkIdentifier(s, "field name"))]);
+  }
+  /** The pipequery text of this expression. */
+  toString() {
+    const text = _chunkLWM2ZXGDcjs.printQuery.call(void 0, {
+      kind: "Pipeline",
+      source: "_data",
+      operations: [{ kind: "SelectOp", fields: [this[NODE]] }]
+    });
+    const prefix = "_data | select(";
+    return text.slice(prefix.length, -1);
+  }
+};
+function fieldProxy(path) {
+  const target = new Expr({ kind: "FieldAccess", path });
+  return new Proxy(target, {
+    get(t, prop, receiver) {
+      if (typeof prop === "symbol" || prop in t) return Reflect.get(t, prop, receiver);
+      return fieldProxy([...path, prop]);
+    }
+  });
+}
+function rowProxy() {
+  return new Proxy({}, {
+    get(_t, prop) {
+      return typeof prop === "symbol" ? void 0 : fieldProxy([prop]);
+    }
+  });
+}
+function col(...path) {
+  if (path.length === 0) throw new BuilderError("col() requires a field name");
+  return fieldProxy(path.flatMap(fieldPath));
+}
+function lit(value) {
+  return new Expr(toAst(value, "literal"));
+}
+function aggregateArgs(name, args) {
+  if (!_chunkLWM2ZXGDcjs.AGGREGATE_NAMES.has(name)) throw new BuilderError(`unknown aggregate "${name}"`);
+  const defined = trimArgs(args);
+  if (defined.length !== args.length) {
+    throw new BuilderError(`${name}(): undefined argument`);
+  }
+  if (_chunkLWM2ZXGDcjs.TWO_ARG_AGGREGATES.has(name)) {
+    if (args.length !== 2) throw new BuilderError(`${name}() expects exactly 2 arguments, got ${args.length}`);
+  } else if (name === "count") {
+    if (args.length > 1) throw new BuilderError(`count() expects at most 1 argument, got ${args.length}`);
+  } else if (args.length !== 1) {
+    throw new BuilderError(`${name}() expects exactly 1 field argument, got ${args.length}`);
+  }
+  return args.map((a, i) => toFieldAst(a, `argument ${i + 1} of ${name}()`));
+}
+function makeAggregates() {
+  const helpers = {};
+  for (const name of _chunkLWM2ZXGDcjs.AGGREGATE_NAMES) {
+    helpers[name] = (...args) => new Expr({ kind: "FunctionCall", name, args: aggregateArgs(name, args) });
+  }
+  return helpers;
+}
+var agg = makeAggregates();
+var fnImpl = {
+  if: (cond, then, otherwise) => scalarCall("if", trimArgs([cond, then, otherwise])),
+  coalesce: (...args) => scalarCall("coalesce", args),
+  lower: (value) => scalarCall("lower", [value]),
+  upper: (value) => scalarCall("upper", [value]),
+  len: (value) => scalarCall("len", [value]),
+  abs: (value) => scalarCall("abs", [value]),
+  round: (value, precision) => scalarCall("round", trimArgs([value, precision])),
+  concat: (...args) => scalarCall("concat", args),
+  contains: (value, search) => scalarCall("contains", [value, search]),
+  startsWith: (value, prefix) => scalarCall("startsWith", [value, prefix]),
+  endsWith: (value, suffix) => scalarCall("endsWith", [value, suffix]),
+  trim: (value) => scalarCall("trim", [value]),
+  substring: (value, start, length) => scalarCall("substring", trimArgs([value, start, length])),
+  replace: (value, search, replacement) => scalarCall("replace", [value, search, replacement])
+};
+var fn = fnImpl;
+function windowCall(name, field, offset) {
+  const args = [];
+  if (field !== void 0) args.push(toFieldAst(field, `field of ${name}()`));
+  if (offset !== void 0) {
+    if (!Number.isInteger(offset) || offset < 1) {
+      throw new BuilderError(`${name}(): offset must be an integer >= 1, got ${String(offset)}`);
+    }
+    args.push({ kind: "NumberLiteral", value: offset });
+  }
+  return new Expr({ kind: "FunctionCall", name, args });
+}
+var winImpl = {
+  running_sum: (field) => windowCall("running_sum", field),
+  running_avg: (field) => windowCall("running_avg", field),
+  running_min: (field) => windowCall("running_min", field),
+  running_max: (field) => windowCall("running_max", field),
+  running_count: (field) => windowCall("running_count", field),
+  row_number: () => windowCall("row_number", void 0),
+  lag: (field, offset) => windowCall("lag", field, offset),
+  lead: (field, offset) => windowCall("lead", field, offset)
+};
+var win = winImpl;
+var WINDOW_NAMES = /* @__PURE__ */ new Set([
+  "running_sum",
+  "running_avg",
+  "running_count",
+  "running_min",
+  "running_max",
+  "row_number",
+  "lag",
+  "lead"
+]);
+function unalias(expr) {
+  return expr.kind === "AliasExpr" ? expr.expression : expr;
+}
+function findCall(expr, pred) {
+  switch (expr.kind) {
+    case "FunctionCall": {
+      if (pred(expr.name)) return expr.name;
+      for (const a of expr.args) {
+        const hit = findCall(a, pred);
+        if (hit) return hit;
+      }
+      return void 0;
+    }
+    case "BinaryExpr":
+      return _nullishCoalesce(findCall(expr.left, pred), () => ( findCall(expr.right, pred)));
+    case "UnaryExpr":
+      return findCall(expr.operand, pred);
+    case "AliasExpr":
+      return findCall(expr.expression, pred);
+    default:
+      return void 0;
+  }
+}
+function hasFieldAccess(expr) {
+  switch (expr.kind) {
+    case "FieldAccess":
+      return true;
+    case "FunctionCall":
+      return expr.args.some(hasFieldAccess);
+    case "BinaryExpr":
+      return hasFieldAccess(expr.left) || hasFieldAccess(expr.right);
+    case "UnaryExpr":
+      return hasFieldAccess(expr.operand);
+    case "AliasExpr":
+      return hasFieldAccess(expr.expression);
+    default:
+      return false;
+  }
+}
+function isAggregateCall(expr) {
+  const e = unalias(expr);
+  return e.kind === "FunctionCall" && _chunkLWM2ZXGDcjs.AGGREGATE_NAMES.has(e.name);
+}
+
+// src/builder/query.ts
+function collect(args, proxies = () => [rowProxy()]) {
+  const out = [];
+  for (const arg of args) {
+    const fromCallback = typeof arg === "function";
+    const value = fromCallback ? arg(...proxies()) : arg;
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      if (fromCallback && typeof item === "string") {
+        throw new BuilderError(
+          "callbacks must return expressions, not strings (a string is a raw pipequery fragment only when passed directly)"
+        );
+      }
+      out.push(item);
+    }
+  }
+  return out;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function aliasEntries(obj) {
+  return Object.entries(obj).map(([name, value]) => {
+    checkIdentifier(name, "alias");
+    const node = unalias(toAst(value, `value of "${name}"`));
+    if (node.kind === "FieldAccess" && node.path[node.path.length - 1] === name) return node;
+    return { kind: "AliasExpr", expression: node, alias: name };
+  });
+}
+function toExprs(items, parseRaw, allowObjects = false) {
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      const parsed = parseRaw(item);
+      if (parsed.length === 0) throw new BuilderError("empty expression string");
+      out.push(...parsed);
+    } else if (allowObjects && isPlainObject(item)) {
+      out.push(...aliasEntries(item));
+    } else {
+      out.push(toAst(item, "expression"));
+    }
+  }
+  return out;
+}
+var keysParser = (label) => (raw) => parseOrExprList(raw, label);
+var exprsParser = (label) => (raw) => parseExprList(raw, label);
+function one(arg, parseRaw, what) {
+  const exprs = toExprs(collect([arg]), parseRaw);
+  if (exprs.length !== 1) {
+    throw new BuilderError(`${what} expects exactly one expression, got ${exprs.length}`);
+  }
+  return exprs[0];
+}
+function toCriteria(items) {
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      out.push(...parseSortCriteria(item));
+    } else if (item instanceof SortKey) {
+      out.push({ expression: item.expression, direction: item.direction });
+    } else {
+      out.push({ expression: toAst(item, "sort key"), direction: "asc" });
+    }
+  }
+  return out;
+}
+function nonNegativeInteger(value, what) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new BuilderError(`${what} must be a non-negative integer, got ${String(value)}`);
+  }
+  return value;
+}
+function fieldRef(value, what) {
+  if (typeof value === "string") return { kind: "FieldAccess", path: fieldPath(value) };
+  const node = toAst(value, what);
+  if (node.kind !== "FieldAccess") {
+    throw new BuilderError(`${what} must be a field reference`);
+  }
+  return node;
+}
+function producesGrouped(op, wasGrouped) {
+  if (op.kind === "GroupByOp") return true;
+  if (op.kind === "MapOp") return wasGrouped;
+  return false;
+}
+function noAggregate(exprs, where) {
+  for (const e of exprs) {
+    const hit = findCall(e, (n) => _chunkLWM2ZXGDcjs.AGGREGATE_NAMES.has(n));
+    if (hit) {
+      throw new BuilderError(
+        `${where}: aggregate ${hit}() is not allowed here (aggregates belong in rollup(), pivot(), select()/map() after groupBy(), or a terminal aggregate)`
+      );
+    }
+  }
+}
+function windowOffsets(expr) {
+  const e = unalias(expr);
+  if (e.kind !== "FunctionCall" || e.name !== "lag" && e.name !== "lead" || e.args.length < 2) return;
+  const offset = e.args[1];
+  if (offset.kind !== "NumberLiteral" || !Number.isInteger(offset.value) || offset.value < 1) {
+    throw new BuilderError(`${e.name}(): offset must be an integer >= 1`);
+  }
+}
+function noWindow(exprs, where) {
+  for (const e of exprs) {
+    const hit = findCall(e, (n) => WINDOW_NAMES.has(n));
+    if (hit) {
+      throw new BuilderError(`${where}: window function ${hit}() is only supported as a top-level field of select()`);
+    }
+  }
+}
+function validateContext(op, grouped) {
+  switch (op.kind) {
+    case "WhereOp":
+      noAggregate([op.condition], "where");
+      noWindow([op.condition], "where");
+      break;
+    case "SortOp": {
+      const exprs = op.criteria.map((c) => c.expression);
+      noAggregate(exprs, "sort");
+      noWindow(exprs, "sort");
+      break;
+    }
+    case "GroupByOp":
+      noAggregate(op.keys, "groupBy");
+      noWindow(op.keys, "groupBy");
+      break;
+    case "JoinOp":
+      noAggregate([op.condition], "join");
+      noWindow([op.condition], "join");
+      break;
+    case "FirstOp":
+      nonNegativeInteger(op.count, "first() count");
+      break;
+    case "LastOp":
+      nonNegativeInteger(op.count, "last() count");
+      break;
+    case "DistinctOp":
+      noAggregate(_nullishCoalesce(op.fields, () => ( [])), "distinct");
+      noWindow(_nullishCoalesce(op.fields, () => ( [])), "distinct");
+      break;
+    case "FlattenOp":
+      noAggregate(op.field ? [op.field] : [], "flatten");
+      noWindow(op.field ? [op.field] : [], "flatten");
+      break;
+    case "TransposeOp":
+      noAggregate(op.headerField ? [op.headerField] : [], "transpose");
+      noWindow(op.headerField ? [op.headerField] : [], "transpose");
+      break;
+    case "SelectOp":
+    case "MapOp": {
+      const label = op.kind === "SelectOp" ? "select" : "map";
+      if (!grouped) noAggregate(op.fields, `${label} (outside groupBy)`);
+      for (const f of op.fields) windowOffsets(f);
+      if (op.kind === "MapOp") {
+        noWindow(op.fields, "map");
+      } else {
+        for (const f of op.fields) {
+          const e = unalias(f);
+          noWindow(e.kind === "FunctionCall" && WINDOW_NAMES.has(e.name) ? e.args : [f], "select");
+        }
+      }
+      break;
+    }
+    case "RollupOp":
+      noAggregate(op.keys, "rollup keys");
+      noWindow([...op.keys, ...op.aggregates], "rollup");
+      break;
+    case "PivotOp":
+      noAggregate([op.pivotField], "pivot field");
+      noWindow([op.pivotField, ...op.aggregates], "pivot");
+      for (const a of op.aggregates) {
+        if (!findCall(a, (n) => _chunkLWM2ZXGDcjs.AGGREGATE_NAMES.has(n))) {
+          throw new BuilderError("pivot: every value must be an aggregate expression such as sum(amount)");
+        }
+      }
+      break;
+    case "ReduceOp":
+      if (hasFieldAccess(op.initial)) {
+        throw new BuilderError("reduce: the initial value is evaluated before any row and cannot reference fields");
+      }
+      noAggregate([op.initial, op.accumulator], "reduce");
+      noWindow([op.initial, op.accumulator], "reduce");
+      break;
+    case "AggregateOp": {
+      const exprs = [..._nullishCoalesce(op.args, () => ( [])), ...op.field ? [op.field] : []];
+      noAggregate(exprs, op.function);
+      noWindow(exprs, op.function);
+      break;
+    }
+    default:
+      break;
+  }
+}
+var Built = class {
+  constructor(sourceName, ops) {
+    this.sourceName = sourceName;
+    this.ops = ops;
+  }
+  
+  
+  
+  /** The pipeline AST (a fresh object each time; expression nodes are shared). */
+  get ast() {
+    return { kind: "Pipeline", source: this.sourceName, operations: [...this.ops] };
+  }
+  /** Canonical pipequery text, via `printQuery`. */
+  toString() {
+    return _chunkLWM2ZXGDcjs.printQuery.call(void 0, this.ast);
+  }
+  /** Compile the AST directly (no print + re-parse). */
+  compile() {
+    return this.compiled ??= _chunkLWM2ZXGDcjs.compileAst.call(void 0, this.ast);
+  }
+  execute(context) {
+    const ctx = Array.isArray(context) ? { [this.sourceName]: context } : context;
+    return this.compile()(ctx);
+  }
+};
+var Scalar = class extends Built {
+  /** @internal */
+  constructor(source, ops) {
+    super(source, ops);
+  }
+  /** Run against `{ source: rows, ... }` or, for plain arrays, the rows of this query's source. */
+  run(context) {
+    return this.execute(context);
+  }
+};
+var Query = class _Query extends Built {
+  /** @internal use `from()` */
+  constructor(source, ops = []) {
+    super(source, ops);
+  }
+  isGrouped() {
+    let grouped = false;
+    for (const op of this.ops) grouped = producesGrouped(op, grouped);
+    return grouped;
+  }
+  /** Validate and append operations. */
+  extend(added) {
+    let grouped = this.isGrouped();
+    for (const op of added) {
+      validateOperation(op);
+      validateContext(op, grouped);
+      grouped = producesGrouped(op, grouped);
+    }
+    return new _Query(this.sourceName, [...this.ops, ...added]);
+  }
+  terminal(op) {
+    validateOperation(op);
+    validateContext(op, this.isGrouped());
+    return new Scalar(this.sourceName, [...this.ops, op]);
+  }
+  /** Run against `{ source: rows, ... }` or, for plain arrays, the rows of this query's source. */
+  run(context) {
+    return this.execute(context);
+  }
+  // ── pipe ops ──────────────────────────────────────────────────────────
+  /** Rows matching the condition. Aggregates and window functions are not allowed here. */
+  where(condition) {
+    const expr = one(condition, (raw) => [parseSingleOp("where", raw, "WhereOp").condition], "where()");
+    return this.extend([{ kind: "WhereOp", condition: expr }]);
+  }
+  select(...fields) {
+    const exprs = toExprs(collect(fields), parseExprList, true);
+    if (exprs.length === 0) throw new BuilderError("select() requires at least one field");
+    return this.extend([{ kind: "SelectOp", fields: exprs }]);
+  }
+  /** Sort keys must be row expressions: no aliases, no aggregates. */
+  sort(...keys) {
+    const criteria = toCriteria(collect(keys));
+    if (criteria.length === 0) throw new BuilderError("sort() requires at least one key");
+    return this.extend([{ kind: "SortOp", criteria }]);
+  }
+  /**
+   * Group rows. Follow with `select`/`map` (aggregates allowed), `rollup` or `pivot`.
+   * A bare `groupBy` yields `{ ...keys, _group }` rows and is rarely what you want to run.
+   * No keys groups everything into one group.
+   */
+  groupBy(...keys) {
+    const exprs = toExprs(collect(keys), parseOrExprList);
+    return this.extend([{ kind: "GroupByOp", keys: exprs }]);
+  }
+  /**
+   * Join with another source from the run context. The engine merges rows as
+   * `{ ...left, ...right }`, so on a name collision the right value wins.
+   * `FieldAccess == FieldAccess` conditions (also `{ on: [left, right] }`) use the hash join.
+   * In callbacks both arguments are plain row proxies; for non-equi conditions the
+   * condition sees the merged row, so qualify nothing and avoid colliding names.
+   */
+  join(right, on) {
+    validateSource(right);
+    let condition;
+    if (typeof on === "string") {
+      condition = parseSingleOp("join", on, "JoinOp", `${right}, `).condition;
+    } else if (typeof on === "function") {
+      const result = on(rowProxy(), rowProxy());
+      if (typeof result === "string") {
+        throw new BuilderError("join callbacks must return an expression, not a string");
+      }
+      condition = toAst(result, "join condition");
+    } else if (on instanceof Expr) {
+      condition = toAst(on, "join condition");
+    } else if (isPlainObject(on) && Array.isArray(on.on)) {
+      const pair = on.on;
+      if (pair.length !== 2) throw new BuilderError("join({ on }) expects [leftField, rightField]");
+      condition = {
+        kind: "BinaryExpr",
+        operator: "==",
+        left: fieldRef(pair[0], "left join key"),
+        right: fieldRef(pair[1], "right join key")
+      };
+    } else {
+      throw new BuilderError("join() condition must be a string, expression, callback or { on: [left, right] }");
+    }
+    return this.extend([{ kind: "JoinOp", right, condition }]);
+  }
+  first(count) {
+    return this.extend([{ kind: "FirstOp", count: nonNegativeInteger(count, "first() count") }]);
+  }
+  /**
+   * The last `count` rows. Engine quirk, passed through unchanged: `last(0)` returns
+   * every row (the engine does `slice(-0)`), unlike `first(0)` which returns none.
+   */
+  last(count) {
+    return this.extend([{ kind: "LastOp", count: nonNegativeInteger(count, "last() count") }]);
+  }
+  /** Distinct rows, or distinct by the given fields. */
+  distinct(...fields) {
+    const exprs = toExprs(collect(fields), keysParser("distinct()"));
+    return this.extend([{ kind: "DistinctOp", fields: exprs.length > 0 ? exprs : void 0 }]);
+  }
+  /** Flatten nested arrays, or the array held in `field`. */
+  flatten(field) {
+    const expr = field === void 0 ? void 0 : one(field, keysParser("flatten()"), "flatten()");
+    return this.extend([{ kind: "FlattenOp", field: expr }]);
+  }
+  transpose(headerField) {
+    const expr = headerField === void 0 ? void 0 : one(headerField, keysParser("transpose()"), "transpose()");
+    return this.extend([{ kind: "TransposeOp", headerField: expr }]);
+  }
+  /**
+   * Group keys first, then at least one aggregate:
+   * `rollup('region', agg.sum(o.total).as('total'))`.
+   */
+  rollup(...items) {
+    const exprs = toExprs(collect(items), exprsParser("rollup()"));
+    const keys = [];
+    const aggregates = [];
+    for (const e of exprs) {
+      if (isAggregateCall(e)) {
+        aggregates.push(e);
+      } else if (aggregates.length > 0) {
+        throw new BuilderError("rollup(): group keys must come before aggregate expressions");
+      } else {
+        keys.push(e);
+      }
+    }
+    if (aggregates.length === 0) {
+      throw new BuilderError("rollup(): at least one aggregate expression is required");
+    }
+    return this.extend([{ kind: "RollupOp", keys, aggregates }]);
+  }
+  /** Pivot on `field`, computing the given aggregates for each pivot value. */
+  pivot(field, ...aggregates) {
+    const pivotField = one(field, keysParser("pivot() field"), "pivot() field");
+    const exprs = toExprs(collect(aggregates), exprsParser("pivot()"));
+    if (exprs.length === 0) throw new BuilderError("pivot(): at least one aggregate expression is required");
+    return this.extend([{ kind: "PivotOp", pivotField, aggregates: exprs }]);
+  }
+  map(...fields) {
+    const exprs = toExprs(collect(fields), exprsParser("map()"), true);
+    if (exprs.length === 0) throw new BuilderError("map() requires at least one field");
+    return this.extend([{ kind: "MapOp", fields: exprs }]);
+  }
+  /**
+   * Fold rows into one value. `initial` cannot reference fields; the accumulator sees the
+   * row's fields plus `_acc`: `reduce(0, (o) => o._acc.plus(o.total))`.
+   * Strings are raw pipequery fragments; use `lit()` for string literals.
+   */
+  reduce(initial, accumulator) {
+    const initialExpr = typeof initial === "string" ? one(initial, exprsParser("reduce() initial value"), "reduce() initial value") : typeof initial === "function" ? one(initial, exprsParser("reduce() initial value"), "reduce() initial value") : toAst(initial, "reduce() initial value");
+    const accumulatorExpr = one(accumulator, exprsParser("reduce() accumulator"), "reduce() accumulator");
+    return this.terminal({ kind: "ReduceOp", initial: initialExpr, accumulator: accumulatorExpr });
+  }
+  /**
+   * Escape hatch: splice raw pipequery operations, parsed with the real parser.
+   * Accepts `'where(x > 1)'`, `'where(x > 1) | first(3)'` (optional leading `|`), or an AST operation.
+   */
+  pipe(raw) {
+    if (typeof raw === "string") {
+      const text = raw.replace(/^\s*\|/, "");
+      const ops = parseOperations(text, 0, "pipe()");
+      if (ops.length === 0) throw new BuilderError("pipe() requires at least one operation");
+      return this.extend(ops);
+    }
+    if (typeof raw !== "object" || raw === null || typeof raw.kind !== "string") {
+      throw new BuilderError("pipe() expects a pipequery string or an operation node");
+    }
+    return this.extend([raw]);
+  }
+  /** @internal used by the terminal aggregate methods installed below. */
+  aggregate(name, args) {
+    const resolved = collect(args);
+    const asts = aggregateArgs(name, resolved);
+    const op = _chunkLWM2ZXGDcjs.TWO_ARG_AGGREGATES.has(name) ? { kind: "AggregateOp", function: name, args: asts } : { kind: "AggregateOp", function: name, field: asts[0] };
+    return this.terminal(op);
+  }
+};
+for (const name of _chunkLWM2ZXGDcjs.AGGREGATE_NAMES) {
+  Object.defineProperty(Query.prototype, name, {
+    configurable: true,
+    writable: true,
+    value: function(...args) {
+      return this.aggregate(name, args);
+    }
+  });
+}
+function from(source) {
+  const name = source === void 0 ? "_data" : validateSource(source);
+  return new Query(name);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BuilderError = BuilderError; exports.Expr = Expr; exports.Query = Query; exports.Scalar = Scalar; exports.SortKey = SortKey; exports.agg = agg; exports.col = col; exports.fn = fn; exports.from = from; exports.lit = lit; exports.toAst = toAst; exports.win = win;