@vaultgradient/pipequery-cli 0.10.3 → 0.10.5

package/dist/sources/manager.js

@@ -0,0 +1,3854 @@
+// src/utils/parseDuration.ts
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+function parseDuration(input) {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
+  if (!match) throw new Error(`Invalid duration: "${input}". Use format like "30s", "5m", "1h".`);
+  return parseFloat(match[1]) * UNITS[match[2]];
+}
+
+// src/utils/expandEnv.ts
+function expandEnv(input, context) {
+  return input.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => {
+    const value = process.env[name];
+    if (value === void 0) {
+      process.stderr.write(
+        `[pipequery] env var "${name}" referenced in ${context} is not set
+`
+      );
+      return "";
+    }
+    return value;
+  });
+}
+
+// src/server/sources/rest.ts
+function extractPath(obj, path) {
+  let current = obj;
+  for (const key of path.split(".")) {
+    if (current == null || typeof current !== "object") return [];
+    current = current[key];
+  }
+  return Array.isArray(current) ? current : [];
+}
+var RestSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  async start() {
+    await this.fetch();
+    const interval = this.config.interval ? parseDuration(this.config.interval) : 3e4;
+    this.timer = setInterval(() => this.fetch(), interval);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  async fetch() {
+    try {
+      let url = expandEnv(this.config.url, "rest source URL");
+      if (this.config.params) {
+        const expanded = {};
+        for (const [k, v] of Object.entries(this.config.params)) {
+          expanded[k] = expandEnv(v, `rest source param "${k}"`);
+        }
+        const params = new URLSearchParams(expanded);
+        url += (url.includes("?") ? "&" : "?") + params.toString();
+      }
+      const headers = this.buildHeaders();
+      const res = await globalThis.fetch(url, { headers });
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      const json = await res.json();
+      this.data = this.config.dataPath ? extractPath(json, this.config.dataPath) : Array.isArray(json) ? json : [json];
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+  /**
+   * Build the final HTTP headers for one fetch.
+   *
+   * Two sources contribute, in order: any user-declared `headers` (with
+   * env-var interpolation applied per value), then the `auth` helper
+   * (currently just `bearer`). Auth wins on collision — if a user sets
+   * both `headers.Authorization` and `auth.kind === 'bearer'`, the bearer
+   * helper is what they actually meant.
+   */
+  buildHeaders() {
+    const headers = {};
+    if (this.config.headers) {
+      for (const [k, v] of Object.entries(this.config.headers)) {
+        headers[k] = expandEnv(v, `rest source header "${k}"`);
+      }
+    }
+    if (this.config.auth?.kind === "bearer") {
+      const token = expandEnv(this.config.auth.token, "rest source bearer token");
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return Object.keys(headers).length > 0 ? headers : void 0;
+  }
+};
+
+// src/server/sources/websocket.ts
+import WebSocket from "ws";
+var WebSocketSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.maxBuffer = config.maxBuffer ?? 1e3;
+  }
+  config;
+  data = [];
+  ws = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  maxBuffer;
+  heartbeatTimer = null;
+  /** Tracks whether stop() was called so reconnect respects intent. */
+  stopped = false;
+  async start() {
+    this.stopped = false;
+    return new Promise((resolve3, reject) => {
+      const ws = new WebSocket(this.config.url);
+      this.ws = ws;
+      let settled = false;
+      ws.on("open", () => {
+        this.error = void 0;
+        try {
+          this.sendSubscribePayloads(ws);
+          this.startHeartbeat(ws);
+        } catch (err) {
+          this.error = err instanceof Error ? err.message : String(err);
+          ws.close();
+          if (!settled) {
+            settled = true;
+            reject(err instanceof Error ? err : new Error(this.error));
+          }
+          return;
+        }
+        if (!settled) {
+          settled = true;
+          resolve3();
+        }
+      });
+      ws.on("message", (raw) => {
+        try {
+          const parsed = JSON.parse(raw.toString());
+          if (Array.isArray(parsed)) {
+            this.data = parsed;
+          } else {
+            this.data.push(parsed);
+            if (this.data.length > this.maxBuffer) {
+              this.data = this.data.slice(-this.maxBuffer);
+            }
+          }
+          this.lastFetch = /* @__PURE__ */ new Date();
+          this.error = void 0;
+          this.notify();
+        } catch {
+        }
+      });
+      ws.on("error", (err) => {
+        this.error = err.message;
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
+      });
+      ws.on("close", () => {
+        this.stopHeartbeat();
+        if (this.stopped) return;
+        setTimeout(() => {
+          if (!this.stopped) this.start().catch(() => {
+          });
+        }, 5e3);
+      });
+    });
+  }
+  stop() {
+    this.stopped = true;
+    this.stopHeartbeat();
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close();
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: this.ws?.readyState === WebSocket.OPEN,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+  sendSubscribePayloads(ws) {
+    const subscribe = this.config.subscribe;
+    if (subscribe === void 0 || subscribe === null) return;
+    const list = Array.isArray(subscribe) ? subscribe : [subscribe];
+    for (const payload of list) {
+      ws.send(JSON.stringify(payload));
+    }
+  }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    const hb = this.config.heartbeat;
+    if (!hb) return;
+    const intervalMs = parseDuration(hb.interval);
+    this.heartbeatTimer = setInterval(() => {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      try {
+        ws.send(JSON.stringify(hb.payload));
+      } catch {
+      }
+    }, intervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+};
+
+// src/server/sources/file.ts
+import { readFile } from "fs/promises";
+import { extname, resolve } from "path";
+import { watch } from "chokidar";
+import { parse as csvParse } from "csv-parse/sync";
+var FileSourceAdapter = class {
+  constructor(config, cwd) {
+    this.config = config;
+    this.cwd = cwd;
+    this.resolvedPath = resolve(cwd, config.path);
+  }
+  config;
+  cwd;
+  data = [];
+  watcher = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  resolvedPath;
+  async start() {
+    await this.load();
+    if (this.config.watch) {
+      this.watcher = watch(this.resolvedPath, { ignoreInitial: true });
+      this.watcher.on("change", () => this.load());
+    }
+  }
+  stop() {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async load() {
+    try {
+      const content = await readFile(this.resolvedPath, "utf-8");
+      const format = this.config.format ?? this.detectFormat();
+      if (format === "csv") {
+        this.data = csvParse(content, { columns: true, skip_empty_lines: true, cast: true });
+      } else {
+        const parsed = JSON.parse(content);
+        this.data = Array.isArray(parsed) ? parsed : [parsed];
+      }
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  detectFormat() {
+    const ext = extname(this.resolvedPath).toLowerCase();
+    return ext === ".csv" || ext === ".tsv" ? "csv" : "json";
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+
+// src/server/sources/static.ts
+var StaticSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  async start() {
+  }
+  stop() {
+  }
+  getData() {
+    return this.config.data;
+  }
+  getStatus() {
+    return {
+      healthy: true,
+      rowCount: this.config.data.length,
+      lastFetch: /* @__PURE__ */ new Date()
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+};
+
+// src/server/sources/postgres.ts
+import pg from "pg";
+
+// ../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 field2;
+        if (peek().type !== "RPAREN") {
+          field2 = parseOrExpr();
+        }
+        op = { kind: "FlattenOp", field: field2 };
+        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 field2;
+            if (peek().type !== "RPAREN") {
+              field2 = parseOrExpr();
+            }
+            op = { kind: "AggregateOp", function: name, field: field2 };
+          }
+          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 field2 = path[0];
+    fn = (obj) => obj[field2];
+  } 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 field2 of allFields) {
+    const row = { _field: field2 };
+    for (let i = 0; i < data.length; i++) {
+      row[colNames[i]] = data[i][field2] ?? 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((field2) => {
+        const name = resolveFieldName(field2);
+        const fn = compileExpression(field2, 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((field2) => {
+    const name = resolveFieldName(field2);
+    const fn = compileExpression(field2, 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/index.ts
+var defaultCache = new QueryCache(128);
+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;
+}
+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 = normalizeExpression(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);
+}
+
+// src/server/sources/pushdown/compile.ts
+var BINARY_OP_SQL = {
+  ">": ">",
+  ">=": ">=",
+  "<": "<",
+  "<=": "<=",
+  "==": "=",
+  "!=": "<>",
+  "&&": "AND",
+  "||": "OR",
+  "+": "+",
+  "-": "-",
+  "*": "*",
+  "/": "/",
+  "%": "%"
+};
+var SQL_AGGREGATE_FN = {
+  sum: (arg) => `SUM(${arg ?? "*"})`,
+  avg: (arg) => `AVG(${arg ?? "*"})`,
+  min: (arg) => `MIN(${arg ?? "*"})`,
+  max: (arg) => `MAX(${arg ?? "*"})`,
+  count: (arg) => `COUNT(${arg ?? "*"})`,
+  distinct_count: (arg) => `COUNT(DISTINCT ${arg ?? "*"})`
+};
+function compileForDialect(pipeline, baseQuery, dialect) {
+  const ctx = {
+    baseSelect: stripTrailingSemicolon(baseQuery),
+    params: [],
+    dialect
+  };
+  let where = null;
+  let orderBy = null;
+  let limit = null;
+  let selectClause = null;
+  let distinctClause = false;
+  let groupByClause = null;
+  let grouped = false;
+  for (const op of pipeline.operations) {
+    switch (op.kind) {
+      case "WhereOp": {
+        if (grouped) {
+          return { ok: false, reason: "where after grouping (HAVING) is not yet pushable" };
+        }
+        const compiled = compileExpr(op.condition, ctx);
+        if (compiled === null) {
+          return { ok: false, reason: "where(): unsupported expression node" };
+        }
+        where = where ? `(${where}) AND (${compiled})` : compiled;
+        break;
+      }
+      case "SortOp": {
+        const parts = [];
+        for (const c of op.criteria) {
+          if (c.expression.kind !== "FieldAccess" || c.expression.path.length !== 1) {
+            return { ok: false, reason: "sort(): only single-field paths supported" };
+          }
+          const ident = ctx.dialect.quoteIdent(c.expression.path[0]);
+          parts.push(`${ident} ${c.direction === "desc" ? "DESC" : "ASC"}`);
+        }
+        orderBy = parts.join(", ");
+        break;
+      }
+      case "FirstOp": {
+        limit = op.count;
+        break;
+      }
+      case "SelectOp": {
+        if (grouped) {
+          return { ok: false, reason: "select after rollup is not yet pushable" };
+        }
+        if (selectClause !== null) {
+          return { ok: false, reason: "multiple select() ops in one pipeline" };
+        }
+        const parts = [];
+        for (const f of op.fields) {
+          const compiled = compileSelectField(f, ctx, false);
+          if (compiled === null) {
+            return { ok: false, reason: "select(): unsupported field expression" };
+          }
+          parts.push(compiled);
+        }
+        selectClause = parts.join(", ");
+        break;
+      }
+      case "DistinctOp": {
+        if (op.fields !== void 0 && op.fields.length > 0) {
+          return { ok: false, reason: "distinct(field) is not yet pushable; full-row distinct works" };
+        }
+        if (grouped) {
+          return { ok: false, reason: "distinct after grouping is not yet pushable" };
+        }
+        distinctClause = true;
+        break;
+      }
+      case "RollupOp": {
+        if (grouped) {
+          return { ok: false, reason: "multiple grouping ops (rollup/aggregate) in one pipeline" };
+        }
+        if (selectClause !== null) {
+          return { ok: false, reason: "rollup after select is not yet pushable" };
+        }
+        const keyParts = [];
+        const groupByParts = [];
+        for (const k of op.keys) {
+          if (k.kind !== "FieldAccess" || k.path.length !== 1) {
+            return { ok: false, reason: "rollup(): keys must be single-field paths" };
+          }
+          const ident = ctx.dialect.quoteIdent(k.path[0]);
+          keyParts.push(ident);
+          groupByParts.push(ident);
+        }
+        const aggParts = [];
+        for (const a of op.aggregates) {
+          const compiled = compileSelectField(a, ctx, true);
+          if (compiled === null) {
+            return { ok: false, reason: "rollup(): unsupported aggregate expression" };
+          }
+          aggParts.push(compiled);
+        }
+        selectClause = [...keyParts, ...aggParts].join(", ");
+        groupByClause = groupByParts.length > 0 ? groupByParts.join(", ") : null;
+        grouped = true;
+        break;
+      }
+      case "AggregateOp": {
+        if (grouped) {
+          return { ok: false, reason: "multiple grouping ops (rollup/aggregate) in one pipeline" };
+        }
+        if (selectClause !== null) {
+          return { ok: false, reason: "aggregate after select is not yet pushable" };
+        }
+        const fn = SQL_AGGREGATE_FN[op.function];
+        if (!fn) {
+          return { ok: false, reason: `aggregate "${op.function}" has no SQL push-down` };
+        }
+        if (op.args && op.args.length > 0) {
+          return { ok: false, reason: `aggregate "${op.function}" with extra args is not yet pushable` };
+        }
+        const argSql = op.field === void 0 ? null : compileExpr(op.field, ctx);
+        if (op.field !== void 0 && argSql === null) {
+          return { ok: false, reason: `aggregate "${op.function}": unsupported argument expression` };
+        }
+        selectClause = `${fn(argSql)} AS ${ctx.dialect.quoteIdent(op.function)}`;
+        grouped = true;
+        break;
+      }
+      default:
+        return { ok: false, reason: `${op.kind}: not yet pushable` };
+    }
+  }
+  let sql = `SELECT ${distinctClause ? "DISTINCT " : ""}${selectClause ?? "*"} FROM (${ctx.baseSelect}) AS pq_src`;
+  if (where) sql += ` WHERE ${where}`;
+  if (groupByClause) sql += ` GROUP BY ${groupByClause}`;
+  if (orderBy) sql += ` ORDER BY ${orderBy}`;
+  if (limit !== null) sql += ` LIMIT ${limit}`;
+  return { ok: true, compiled: { sql, params: ctx.params } };
+}
+function compileSelectField(expr, ctx, aggregateContext) {
+  if (expr.kind === "AliasExpr") {
+    const inner = compileSelectField(expr.expression, ctx, aggregateContext);
+    if (inner === null) return null;
+    return `${inner} AS ${ctx.dialect.quoteIdent(expr.alias)}`;
+  }
+  if (expr.kind === "FunctionCall") {
+    if (!aggregateContext) return null;
+    return compileAggregateCall(expr.name, expr.args, ctx);
+  }
+  return compileExpr(expr, ctx);
+}
+function compileAggregateCall(name, args, ctx) {
+  const fn = SQL_AGGREGATE_FN[name];
+  if (!fn) return null;
+  if (args.length === 0) return fn(null);
+  if (args.length > 1) return null;
+  const argSql = compileExpr(args[0], ctx);
+  if (argSql === null) return null;
+  return fn(argSql);
+}
+function compileExpr(expr, ctx) {
+  switch (expr.kind) {
+    case "NumberLiteral":
+    case "StringLiteral":
+    case "BooleanLiteral":
+      return ctx.dialect.bindLiteral(expr.value, ctx.params);
+    case "NullLiteral":
+      return "NULL";
+    case "FieldAccess": {
+      if (expr.path.length !== 1) return null;
+      return ctx.dialect.quoteIdent(expr.path[0]);
+    }
+    case "BinaryExpr": {
+      const opSql = BINARY_OP_SQL[expr.operator];
+      if (!opSql) return null;
+      const left = compileExpr(expr.left, ctx);
+      const right = compileExpr(expr.right, ctx);
+      if (left === null || right === null) return null;
+      if (expr.right.kind === "NullLiteral") {
+        if (expr.operator === "==") return `${left} IS NULL`;
+        if (expr.operator === "!=") return `${left} IS NOT NULL`;
+      }
+      if (expr.left.kind === "NullLiteral") {
+        if (expr.operator === "==") return `${right} IS NULL`;
+        if (expr.operator === "!=") return `${right} IS NOT NULL`;
+      }
+      return `(${left} ${opSql} ${right})`;
+    }
+    case "UnaryExpr": {
+      const operand = compileExpr(expr.operand, ctx);
+      if (operand === null) return null;
+      if (expr.operator === "!") return `(NOT ${operand})`;
+      if (expr.operator === "-") return `(-${operand})`;
+      return null;
+    }
+    case "FunctionCall":
+    case "AliasExpr":
+      return null;
+  }
+}
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/pushdown/dialect.ts
+var POSTGRES_DIALECT = {
+  quoteIdent: (name) => `"${name.replace(/"/g, '""')}"`,
+  bindLiteral: (value, params) => {
+    params.push(value);
+    return `$${params.length}`;
+  }
+};
+var MYSQL_DIALECT = {
+  quoteIdent: (name) => `\`${name.replace(/`/g, "``")}\``,
+  bindLiteral: (value, params) => {
+    params.push(value);
+    return "?";
+  }
+};
+var SNOWFLAKE_DIALECT = {
+  quoteIdent: (name) => `"${name.replace(/"/g, '""')}"`,
+  bindLiteral: (value, params) => {
+    params.push(value);
+    return "?";
+  }
+};
+var CLICKHOUSE_DIALECT = {
+  quoteIdent: (name) => `\`${name.replace(/`/g, "``")}\``,
+  bindLiteral: (value) => clickhouseLiteral(value)
+};
+function clickhouseLiteral(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "boolean") return value ? "1" : "0";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return "NULL";
+    return String(value);
+  }
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    return `'${escaped}'`;
+  }
+  return clickhouseLiteral(String(value));
+}
+
+// src/server/sources/pushdown/postgres.ts
+function compilePostgresPushdown(pipeline, baseQuery) {
+  return compileForDialect(pipeline, baseQuery, POSTGRES_DIALECT);
+}
+
+// src/server/sources/postgres.ts
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_ROWS = 1e4;
+function resolveSsl(ssl) {
+  if (ssl === false) return false;
+  if (ssl === "no-verify") return { rejectUnauthorized: false };
+  return { rejectUnauthorized: true };
+}
+var PostgresSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS;
+  }
+  config;
+  pool = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    const connectionString = expandEnv(this.config.url, "postgres source URL");
+    this.pool = new pg.Pool({
+      connectionString,
+      ssl: resolveSsl(this.config.ssl),
+      // Small pool — we're read-only polling, not a transactional app.
+      min: 0,
+      max: 2,
+      idleTimeoutMillis: 1e4
+    });
+    this.pool.on("error", (err) => {
+      this.error = err.message;
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.pool) {
+      void this.pool.end();
+      this.pool = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  /**
+   * Push-down execution prototype. Compiles a pipequery expression rooted at
+   * this source into a single Postgres query (where / sort / first only in
+   * v1) and runs it directly against the database — no in-memory
+   * materialization of the user's source query, no polling, no ring buffer.
+   *
+   * Returns:
+   *   - `{ ok: true, rows, sql, params, fullyPushed: true }` on a clean push-down
+   *   - `{ ok: false, reason }` when the AST contains operators we don't yet
+   *     translate. Caller should fall back to the in-process engine on the
+   *     ring-buffered data instead.
+   *
+   * This is an opt-in API; the default getData() / fetch() polling loop is
+   * unchanged so existing users see no behaviour change.
+   */
+  async runPushdown(expression) {
+    if (!this.pool) {
+      return { ok: false, reason: "Postgres pool not initialized \u2014 call start() first" };
+    }
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch (err) {
+      return { ok: false, reason: `parse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const compiled = compilePostgresPushdown(pipeline, this.config.query);
+    if (!compiled.ok) {
+      return { ok: false, reason: compiled.reason };
+    }
+    try {
+      const res = await this.pool.query(compiled.compiled.sql, compiled.compiled.params);
+      return {
+        ok: true,
+        rows: res.rows,
+        sql: compiled.compiled.sql,
+        params: compiled.compiled.params,
+        fullyPushed: true
+      };
+    } catch (err) {
+      return { ok: false, reason: `postgres error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  async fetch() {
+    if (!this.pool) {
+      this.error = "Postgres pool not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon2(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const res = await this.pool.query(capQuery);
+      if (res.rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = res.rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon2(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/mysql.ts
+import mysql from "mysql2/promise";
+
+// src/server/sources/pushdown/mysql.ts
+function compileMysqlPushdown(pipeline, baseQuery) {
+  return compileForDialect(pipeline, baseQuery, MYSQL_DIALECT);
+}
+
+// src/server/sources/mysql.ts
+var DEFAULT_INTERVAL_MS2 = 3e4;
+var DEFAULT_MAX_ROWS2 = 1e4;
+function resolveSsl2(ssl) {
+  if (ssl === false) return void 0;
+  if (ssl === "no-verify") return { rejectUnauthorized: false };
+  return { rejectUnauthorized: true };
+}
+var MysqlSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS2;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS2;
+  }
+  config;
+  pool = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    const uri = expandEnv(this.config.url, "mysql source URL");
+    this.pool = mysql.createPool({
+      uri,
+      ssl: resolveSsl2(this.config.ssl),
+      connectionLimit: 2,
+      waitForConnections: true,
+      // mysql2 returns BigInt for large integers by default — stringify so the
+      // data serializes cleanly to JSON (which can't encode BigInt).
+      supportBigNumbers: true,
+      bigNumberStrings: true
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.pool) {
+      void this.pool.end();
+      this.pool = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  /**
+   * Adapter-native push-down. Compiles the pipe expression to MySQL SQL
+   * (see ./pushdown/mysql.ts) and runs it directly. SourceManager.runQuery
+   * dispatches here automatically when the pipeline shape is eligible —
+   * unsupported shapes return `{ ok: false, reason }` and the caller falls
+   * back to the in-process engine.
+   *
+   * Mirrors PostgresSourceAdapter.runPushdown — same shape, same result
+   * type. Both adapters route through the dialect-parametric compiler in
+   * compile.ts.
+   */
+  async runPushdown(expression) {
+    if (!this.pool) {
+      return { ok: false, reason: "MySQL pool not initialized \u2014 call start() first" };
+    }
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch (err) {
+      return { ok: false, reason: `parse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const compiled = compileMysqlPushdown(pipeline, this.config.query);
+    if (!compiled.ok) {
+      return { ok: false, reason: compiled.reason };
+    }
+    try {
+      const [rows] = await this.pool.query(compiled.compiled.sql, compiled.compiled.params);
+      const asArray = Array.isArray(rows) ? rows : [];
+      return {
+        ok: true,
+        rows: asArray,
+        sql: compiled.compiled.sql,
+        params: compiled.compiled.params
+      };
+    } catch (err) {
+      return { ok: false, reason: `mysql error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  async fetch() {
+    if (!this.pool) {
+      this.error = "MySQL pool not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon3(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const [rows] = await this.pool.query(capQuery);
+      const asArray = Array.isArray(rows) ? rows : [];
+      if (asArray.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = asArray;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon3(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/sqlite.ts
+import { resolve as resolve2 } from "path";
+import Database from "better-sqlite3";
+var DEFAULT_INTERVAL_MS3 = 3e4;
+var DEFAULT_MAX_ROWS3 = 1e4;
+var IN_MEMORY = ":memory:";
+var SqliteSourceAdapter = class {
+  constructor(config, cwd) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS3;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS3;
+    this.readonly = config.readonly ?? true;
+    this.resolvedPath = config.path === IN_MEMORY ? IN_MEMORY : resolve2(cwd, config.path);
+  }
+  config;
+  db = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  resolvedPath;
+  readonly;
+  async start() {
+    const opts = this.resolvedPath === IN_MEMORY ? {} : { readonly: this.readonly, fileMustExist: this.readonly };
+    this.db = new Database(this.resolvedPath, opts);
+    if (this.resolvedPath !== IN_MEMORY && !this.readonly) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  async fetch() {
+    if (!this.db) {
+      this.error = "SQLite database not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon4(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const rows = this.db.prepare(capQuery).all();
+      if (rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon4(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/kafka.ts
+import { randomBytes } from "crypto";
+import { Kafka, logLevel } from "kafkajs";
+var DEFAULT_MAX_BUFFER = 1e3;
+function normalizeBrokers(brokers) {
+  const list = Array.isArray(brokers) ? brokers : brokers.split(",");
+  return list.map((b) => expandEnv(b.trim(), "kafka source brokers")).filter(Boolean);
+}
+var KafkaSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.maxBuffer = config.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    this.groupId = config.groupId ?? `pipequery-${randomBytes(6).toString("hex")}`;
+  }
+  config;
+  data = [];
+  kafka = null;
+  consumer = null;
+  lastFetch = null;
+  error;
+  connected = false;
+  listeners = /* @__PURE__ */ new Set();
+  maxBuffer;
+  groupId;
+  async start() {
+    const brokers = normalizeBrokers(this.config.brokers);
+    if (brokers.length === 0) {
+      throw new Error("Kafka source has no brokers configured");
+    }
+    this.kafka = new Kafka({
+      clientId: `pipequery-${this.config.topic}`,
+      brokers,
+      ssl: this.config.ssl ?? false,
+      sasl: this.config.sasl ? {
+        mechanism: this.config.sasl.mechanism,
+        username: expandEnv(this.config.sasl.username, "kafka source SASL username"),
+        password: expandEnv(this.config.sasl.password, "kafka source SASL password")
+      } : void 0,
+      // Silence kafkajs's own logger — we surface errors via SourceStatus.
+      logLevel: logLevel.ERROR
+    });
+    this.consumer = this.kafka.consumer({ groupId: this.groupId });
+    await this.consumer.connect();
+    await this.consumer.subscribe({
+      topic: this.config.topic,
+      fromBeginning: this.config.fromBeginning ?? false
+    });
+    this.connected = true;
+    this.error = void 0;
+    void this.consumer.run({
+      eachMessage: async ({ message, partition }) => {
+        try {
+          const row = this.decode(message.value, message.key, message.timestamp, partition, message.offset);
+          this.data.push(row);
+          if (this.data.length > this.maxBuffer) {
+            this.data = this.data.slice(-this.maxBuffer);
+          }
+          this.lastFetch = /* @__PURE__ */ new Date();
+          this.error = void 0;
+          this.notify();
+        } catch {
+        }
+      }
+    });
+  }
+  stop() {
+    this.connected = false;
+    if (this.consumer) {
+      const consumer = this.consumer;
+      this.consumer = null;
+      void consumer.disconnect().catch(() => {
+      });
+    }
+    this.kafka = null;
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: this.connected && !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  decode(value, key, timestamp, partition, offset) {
+    const base = {
+      _kafka_topic: this.config.topic,
+      _kafka_partition: partition,
+      _kafka_offset: offset,
+      _kafka_timestamp: Number.parseInt(timestamp, 10),
+      _kafka_key: key ? key.toString("utf8") : null
+    };
+    if (!value) {
+      return { ...base, value: null };
+    }
+    const format = this.config.valueFormat ?? "json";
+    if (format === "string") {
+      return { ...base, value: value.toString("utf8") };
+    }
+    if (format === "raw") {
+      return { ...base, value: value.toString("base64") };
+    }
+    const decoded = JSON.parse(value.toString("utf8"));
+    if (decoded !== null && typeof decoded === "object" && !Array.isArray(decoded)) {
+      return { ...base, ...decoded };
+    }
+    return { ...base, value: decoded };
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+
+// src/server/sources/snowflake.ts
+import snowflake from "snowflake-sdk";
+
+// src/server/sources/pushdown/snowflake.ts
+function compileSnowflakePushdown(pipeline, baseQuery) {
+  return compileForDialect(pipeline, baseQuery, SNOWFLAKE_DIALECT);
+}
+
+// src/server/sources/snowflake.ts
+var DEFAULT_INTERVAL_MS4 = 6e4;
+var DEFAULT_MAX_ROWS4 = 1e4;
+var SnowflakeSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS4;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS4;
+  }
+  config;
+  conn = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    this.conn = snowflake.createConnection({
+      account: expandEnv(this.config.account, "snowflake source account"),
+      username: expandEnv(this.config.username, "snowflake source username"),
+      password: expandEnv(this.config.password, "snowflake source password"),
+      ...this.config.database ? { database: expandEnv(this.config.database, "snowflake source database") } : {},
+      ...this.config.schema ? { schema: expandEnv(this.config.schema, "snowflake source schema") } : {},
+      ...this.config.warehouse ? { warehouse: expandEnv(this.config.warehouse, "snowflake source warehouse") } : {},
+      ...this.config.role ? { role: expandEnv(this.config.role, "snowflake source role") } : {}
+    });
+    await new Promise((resolve3, reject) => {
+      this.conn.connect((err) => err ? reject(err) : resolve3());
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.conn) {
+      this.conn.destroy(() => void 0);
+      this.conn = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  /**
+   * Adapter-native push-down. SourceManager.runQuery dispatches here when a
+   * pipeline targets a Snowflake source; declines fall back to in-process.
+   */
+  async runPushdown(expression) {
+    if (!this.conn) {
+      return { ok: false, reason: "Snowflake connection not initialized \u2014 call start() first" };
+    }
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch (err) {
+      return { ok: false, reason: `parse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const compiled = compileSnowflakePushdown(pipeline, this.config.query);
+    if (!compiled.ok) {
+      return { ok: false, reason: compiled.reason };
+    }
+    try {
+      const rows = await this.executeSql(compiled.compiled.sql, compiled.compiled.params);
+      return {
+        ok: true,
+        rows,
+        sql: compiled.compiled.sql,
+        params: compiled.compiled.params
+      };
+    } catch (err) {
+      return { ok: false, reason: `snowflake error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  async fetch() {
+    if (!this.conn) {
+      this.error = "Snowflake connection not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon5(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const rows = await this.executeSql(capQuery, []);
+      if (rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  executeSql(sqlText, params) {
+    return new Promise((resolve3, reject) => {
+      this.conn.execute({
+        sqlText,
+        binds: params,
+        complete: (err, _stmt, rows) => {
+          if (err) reject(err);
+          else resolve3(rows ?? []);
+        }
+      });
+    });
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon5(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/clickhouse.ts
+import { createClient } from "@clickhouse/client";
+
+// src/server/sources/pushdown/clickhouse.ts
+function compileClickhousePushdown(pipeline, baseQuery) {
+  return compileForDialect(pipeline, baseQuery, CLICKHOUSE_DIALECT);
+}
+
+// src/server/sources/clickhouse.ts
+var DEFAULT_INTERVAL_MS5 = 3e4;
+var DEFAULT_MAX_ROWS5 = 1e4;
+var ClickhouseSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS5;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS5;
+  }
+  config;
+  client = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    this.client = createClient({
+      url: expandEnv(this.config.url, "clickhouse source URL"),
+      ...this.config.username ? { username: expandEnv(this.config.username, "clickhouse source username") } : {},
+      ...this.config.password ? { password: expandEnv(this.config.password, "clickhouse source password") } : {},
+      ...this.config.database ? { database: this.config.database } : {}
+    });
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.client) {
+      void this.client.close();
+      this.client = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  /**
+   * Adapter-native push-down. ClickHouse dialect inlines literals (vs.
+   * Postgres / MySQL / Snowflake which bind via placeholders) so the
+   * `params` array returned in the success result is always empty;
+   * the SQL is fully self-contained.
+   */
+  async runPushdown(expression) {
+    if (!this.client) {
+      return { ok: false, reason: "ClickHouse client not initialized \u2014 call start() first" };
+    }
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch (err) {
+      return { ok: false, reason: `parse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const compiled = compileClickhousePushdown(pipeline, this.config.query);
+    if (!compiled.ok) {
+      return { ok: false, reason: compiled.reason };
+    }
+    try {
+      const rows = await this.executeSql(compiled.compiled.sql);
+      return {
+        ok: true,
+        rows,
+        sql: compiled.compiled.sql,
+        params: compiled.compiled.params
+      };
+    } catch (err) {
+      return { ok: false, reason: `clickhouse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  async fetch() {
+    if (!this.client) {
+      this.error = "ClickHouse client not initialized";
+      return;
+    }
+    try {
+      const capQuery = `SELECT * FROM (${stripTrailingSemicolon6(this.config.query)}) AS pq_src LIMIT ${this.maxRows + 1}`;
+      const rows = await this.executeSql(capQuery);
+      if (rows.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Add LIMIT/WHERE to bound the result set, or raise maxRows in the source config.`
+        );
+      }
+      this.data = rows;
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  async executeSql(sql) {
+    const result = await this.client.query({
+      query: sql,
+      format: "JSONEachRow"
+    });
+    const rows = await result.json();
+    return Array.isArray(rows) ? rows : [];
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+function stripTrailingSemicolon6(sql) {
+  return sql.trim().replace(/;+\s*$/, "");
+}
+
+// src/server/sources/mongodb.ts
+import { MongoClient } from "mongodb";
+
+// src/server/sources/pushdown/mongodb.ts
+var CMP_TO_MONGO = {
+  ">": "$gt",
+  ">=": "$gte",
+  "<": "$lt",
+  "<=": "$lte",
+  "==": "$eq",
+  "!=": "$ne"
+};
+var MONGO_AGGREGATE_FN = {
+  sum: (arg) => ({ $sum: arg ?? 1 }),
+  // sum(*) → $sum: 1 (count rows)
+  avg: (arg) => ({ $avg: arg ?? null }),
+  min: (arg) => ({ $min: arg ?? null }),
+  max: (arg) => ({ $max: arg ?? null }),
+  count: () => ({ $sum: 1 }),
+  // count(*) — Mongo idiom
+  distinct_count: (arg) => ({ $addToSet: arg ?? null })
+  // size taken in $project
+};
+function compileMongoPushdown(pipeline, defaultFilter) {
+  let needsAggregate = false;
+  for (const op of pipeline.operations) {
+    if (op.kind === "RollupOp" || op.kind === "AggregateOp") needsAggregate = true;
+    if (op.kind === "DistinctOp") {
+      return { ok: false, reason: "mongo distinct() is not yet pushable; in-process handles it" };
+    }
+    if (op.kind !== "WhereOp" && op.kind !== "SortOp" && op.kind !== "FirstOp" && op.kind !== "SelectOp" && op.kind !== "RollupOp" && op.kind !== "AggregateOp") {
+      return { ok: false, reason: `${op.kind}: not yet pushable to mongo` };
+    }
+  }
+  return needsAggregate ? compileAggregatePipeline(pipeline, defaultFilter) : compileFindPlan(pipeline, defaultFilter);
+}
+function compileFindPlan(pipeline, defaultFilter) {
+  let filter = null;
+  let sort;
+  let limit;
+  let projection;
+  for (const op of pipeline.operations) {
+    if (op.kind === "WhereOp") {
+      const compiled = compileFilter(op.condition);
+      if (compiled === null) {
+        return { ok: false, reason: "where(): unsupported expression node" };
+      }
+      filter = filter ? { $and: [filter, compiled] } : compiled;
+    } else if (op.kind === "SortOp") {
+      sort = {};
+      for (const c of op.criteria) {
+        if (c.expression.kind !== "FieldAccess" || c.expression.path.length !== 1) {
+          return { ok: false, reason: "sort(): only single-field paths supported" };
+        }
+        sort[c.expression.path[0]] = c.direction === "desc" ? -1 : 1;
+      }
+    } else if (op.kind === "FirstOp") {
+      limit = op.count;
+    } else if (op.kind === "SelectOp") {
+      projection = {};
+      for (const f of op.fields) {
+        if (f.kind === "FieldAccess" && f.path.length === 1) {
+          projection[f.path[0]] = 1;
+        } else if (f.kind === "AliasExpr" && f.expression.kind === "FieldAccess" && f.expression.path.length === 1) {
+          return { ok: false, reason: "select() with alias requires aggregate path" };
+        } else {
+          return { ok: false, reason: "select(): only bare field projections in find() path" };
+        }
+      }
+      projection._id = 0;
+    }
+  }
+  const finalFilter = mergeFilters(defaultFilter, filter ?? void 0);
+  return {
+    ok: true,
+    compiled: {
+      kind: "find",
+      filter: finalFilter,
+      ...sort ? { sort } : {},
+      ...limit !== void 0 ? { limit } : {},
+      ...projection ? { projection } : {}
+    }
+  };
+}
+function compileAggregatePipeline(pipeline, defaultFilter) {
+  const stages = [];
+  if (defaultFilter && Object.keys(defaultFilter).length > 0) {
+    stages.push({ $match: { ...defaultFilter } });
+  }
+  let grouped = false;
+  let postGroupProjection = null;
+  for (const op of pipeline.operations) {
+    switch (op.kind) {
+      case "WhereOp": {
+        if (grouped) {
+          return { ok: false, reason: "where after grouping (HAVING) is not yet pushable" };
+        }
+        const compiled = compileFilter(op.condition);
+        if (compiled === null) {
+          return { ok: false, reason: "where(): unsupported expression node" };
+        }
+        stages.push({ $match: compiled });
+        break;
+      }
+      case "SortOp": {
+        const sortStage = {};
+        for (const c of op.criteria) {
+          if (c.expression.kind !== "FieldAccess" || c.expression.path.length !== 1) {
+            return { ok: false, reason: "sort(): only single-field paths supported" };
+          }
+          sortStage[c.expression.path[0]] = c.direction === "desc" ? -1 : 1;
+        }
+        stages.push({ $sort: sortStage });
+        break;
+      }
+      case "FirstOp": {
+        stages.push({ $limit: op.count });
+        break;
+      }
+      case "SelectOp": {
+        if (grouped) {
+          return { ok: false, reason: "select after rollup is not yet pushable" };
+        }
+        const proj = { _id: 0 };
+        for (const f of op.fields) {
+          if (f.kind === "FieldAccess" && f.path.length === 1) {
+            proj[f.path[0]] = 1;
+          } else if (f.kind === "AliasExpr" && f.expression.kind === "FieldAccess" && f.expression.path.length === 1) {
+            proj[f.alias] = `$${f.expression.path[0]}`;
+          } else {
+            return { ok: false, reason: "select(): unsupported field expression in mongo" };
+          }
+        }
+        stages.push({ $project: proj });
+        break;
+      }
+      case "RollupOp": {
+        if (grouped) {
+          return { ok: false, reason: "multiple grouping ops in one pipeline" };
+        }
+        const groupIdResult = compileGroupId(op.keys);
+        if (!groupIdResult.ok) {
+          return { ok: false, reason: "rollup(): keys must be single-field paths" };
+        }
+        const groupStage = { _id: groupIdResult.value };
+        const distinctCountAliases = [];
+        for (const a of op.aggregates) {
+          const alias = a.kind === "AliasExpr" ? a.alias : null;
+          const inner = a.kind === "AliasExpr" ? a.expression : a;
+          if (inner.kind !== "FunctionCall") {
+            return { ok: false, reason: "rollup(): aggregate must be a function call" };
+          }
+          const fn = MONGO_AGGREGATE_FN[inner.name];
+          if (!fn) {
+            return { ok: false, reason: `aggregate "${inner.name}" has no mongo push-down` };
+          }
+          let argRef = null;
+          if (inner.args.length === 1) {
+            const arg = inner.args[0];
+            if (arg.kind !== "FieldAccess" || arg.path.length !== 1) {
+              return { ok: false, reason: "rollup(): aggregate argument must be a single-field path" };
+            }
+            argRef = `$${arg.path[0]}`;
+          } else if (inner.args.length > 1) {
+            return { ok: false, reason: `aggregate "${inner.name}" with extra args not yet pushable` };
+          }
+          const fieldName = alias ?? inner.name;
+          groupStage[fieldName] = fn(argRef);
+          if (inner.name === "distinct_count") {
+            distinctCountAliases.push(fieldName);
+          }
+        }
+        stages.push({ $group: groupStage });
+        const projAfterGroup = {
+          _id: 0
+        };
+        if (op.keys.length === 1) {
+          const k = op.keys[0];
+          if (k.kind === "FieldAccess" && k.path.length === 1) {
+            projAfterGroup[k.path[0]] = "$_id";
+          }
+        } else {
+          for (const k of op.keys) {
+            if (k.kind === "FieldAccess" && k.path.length === 1) {
+              projAfterGroup[k.path[0]] = `$_id.${k.path[0]}`;
+            }
+          }
+        }
+        for (const key of Object.keys(groupStage)) {
+          if (key === "_id") continue;
+          if (distinctCountAliases.includes(key)) {
+            projAfterGroup[key] = { $size: `$${key}` };
+          } else {
+            projAfterGroup[key] = `$${key}`;
+          }
+        }
+        postGroupProjection = projAfterGroup;
+        grouped = true;
+        break;
+      }
+      case "AggregateOp": {
+        if (grouped) {
+          return { ok: false, reason: "multiple grouping ops in one pipeline" };
+        }
+        const fn = MONGO_AGGREGATE_FN[op.function];
+        if (!fn) {
+          return { ok: false, reason: `aggregate "${op.function}" has no mongo push-down` };
+        }
+        if (op.args && op.args.length > 0) {
+          return { ok: false, reason: `aggregate "${op.function}" with extra args not yet pushable` };
+        }
+        let argRef = null;
+        if (op.field !== void 0) {
+          if (op.field.kind !== "FieldAccess" || op.field.path.length !== 1) {
+            return { ok: false, reason: `aggregate "${op.function}": unsupported argument expression` };
+          }
+          argRef = `$${op.field.path[0]}`;
+        }
+        const groupStage = { _id: null, [op.function]: fn(argRef) };
+        stages.push({ $group: groupStage });
+        const proj = { _id: 0, [op.function]: `$${op.function}` };
+        if (op.function === "distinct_count") {
+          proj[op.function] = { $size: `$${op.function}` };
+        }
+        postGroupProjection = proj;
+        grouped = true;
+        break;
+      }
+      default:
+        return { ok: false, reason: `${op.kind}: not yet pushable to mongo` };
+    }
+  }
+  if (postGroupProjection) stages.push({ $project: postGroupProjection });
+  return { ok: true, compiled: { kind: "aggregate", pipeline: stages } };
+}
+function compileFilter(expr) {
+  switch (expr.kind) {
+    case "BinaryExpr": {
+      if (expr.operator === "&&") {
+        const left = compileFilter(expr.left);
+        const right = compileFilter(expr.right);
+        if (left === null || right === null) return null;
+        return { $and: [left, right] };
+      }
+      if (expr.operator === "||") {
+        const left = compileFilter(expr.left);
+        const right = compileFilter(expr.right);
+        if (left === null || right === null) return null;
+        return { $or: [left, right] };
+      }
+      const cmp = CMP_TO_MONGO[expr.operator];
+      if (!cmp) return null;
+      if (expr.right.kind === "NullLiteral") {
+        if (expr.operator === "==") return field(expr.left, { $eq: null });
+        if (expr.operator === "!=") return field(expr.left, { $ne: null });
+      }
+      if (expr.left.kind === "NullLiteral") {
+        if (expr.operator === "==") return field(expr.right, { $eq: null });
+        if (expr.operator === "!=") return field(expr.right, { $ne: null });
+      }
+      const lit = literalValue(expr.right);
+      if (expr.left.kind === "FieldAccess" && lit.ok) {
+        return field(expr.left, { [cmp]: lit.value });
+      }
+      const litLeft = literalValue(expr.left);
+      if (expr.right.kind === "FieldAccess" && litLeft.ok) {
+        const reversed = REVERSE_CMP[expr.operator] ?? expr.operator;
+        const reverseCmp = CMP_TO_MONGO[reversed];
+        if (!reverseCmp) return null;
+        return field(expr.right, { [reverseCmp]: litLeft.value });
+      }
+      return null;
+    }
+    case "UnaryExpr": {
+      if (expr.operator === "!") {
+        const inner = compileFilter(expr.operand);
+        if (inner === null) return null;
+        return { $nor: [inner] };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+var REVERSE_CMP = {
+  ">": "<",
+  ">=": "<=",
+  "<": ">",
+  "<=": ">=",
+  "==": "==",
+  "!=": "!="
+};
+function field(expr, condition) {
+  if (expr.kind !== "FieldAccess" || expr.path.length !== 1) return null;
+  return { [expr.path[0]]: condition };
+}
+function literalValue(expr) {
+  switch (expr.kind) {
+    case "NumberLiteral":
+    case "StringLiteral":
+    case "BooleanLiteral":
+      return { ok: true, value: expr.value };
+    case "NullLiteral":
+      return { ok: true, value: null };
+    default:
+      return { ok: false };
+  }
+}
+function compileGroupId(keys) {
+  if (keys.length === 0) return { ok: true, value: null };
+  if (keys.length === 1) {
+    const k = keys[0];
+    if (k.kind !== "FieldAccess" || k.path.length !== 1) return { ok: false };
+    return { ok: true, value: `$${k.path[0]}` };
+  }
+  const obj = {};
+  for (const k of keys) {
+    if (k.kind !== "FieldAccess" || k.path.length !== 1) return { ok: false };
+    obj[k.path[0]] = `$${k.path[0]}`;
+  }
+  return { ok: true, value: obj };
+}
+function mergeFilters(base, added) {
+  if (!base || Object.keys(base).length === 0) return added ?? {};
+  if (!added || Object.keys(added).length === 0) return { ...base };
+  return { $and: [{ ...base }, { ...added }] };
+}
+
+// src/server/sources/mongodb.ts
+var DEFAULT_INTERVAL_MS6 = 3e4;
+var DEFAULT_MAX_ROWS6 = 1e4;
+var MongoSourceAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.intervalMs = config.interval ? parseDuration(config.interval) : DEFAULT_INTERVAL_MS6;
+    this.maxRows = config.maxRows ?? DEFAULT_MAX_ROWS6;
+  }
+  config;
+  client = null;
+  db = null;
+  collection = null;
+  data = [];
+  timer = null;
+  lastFetch = null;
+  error;
+  listeners = /* @__PURE__ */ new Set();
+  intervalMs;
+  maxRows;
+  async start() {
+    const uri = expandEnv(this.config.url, "mongodb source URL");
+    this.client = new MongoClient(uri);
+    await this.client.connect();
+    this.db = this.client.db(expandEnv(this.config.database, "mongodb source database"));
+    this.collection = this.db.collection(this.config.collection);
+    await this.fetch();
+    this.timer = setInterval(() => {
+      void this.fetch();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.client) {
+      void this.client.close();
+      this.client = null;
+      this.db = null;
+      this.collection = null;
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getStatus() {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error
+    };
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  async refresh() {
+    await this.fetch();
+  }
+  /**
+   * Adapter-native push-down to MongoDB. The compiler emits either a
+   * `find()` plan (when the pipeline only uses where/sort/first/select)
+   * or an `aggregate()` pipeline (when grouping is involved).
+   *
+   * The success result's `sql` field carries a JSON serialization of the
+   * compiled plan (Mongo doesn't have SQL); `params` is empty since
+   * Mongo plans bind values inline as part of the BSON document.
+   */
+  async runPushdown(expression) {
+    if (!this.collection) {
+      return { ok: false, reason: "Mongo collection not initialized \u2014 call start() first" };
+    }
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch (err) {
+      return { ok: false, reason: `parse error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const compiled = compileMongoPushdown(pipeline, this.config.filter);
+    if (!compiled.ok) {
+      return { ok: false, reason: compiled.reason };
+    }
+    try {
+      const rows = await this.runPlan(compiled.compiled);
+      return {
+        ok: true,
+        rows,
+        sql: JSON.stringify(compiled.compiled),
+        params: []
+      };
+    } catch (err) {
+      return { ok: false, reason: `mongo error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  async runPlan(plan) {
+    const coll = this.collection;
+    if (plan.kind === "find") {
+      let cursor = coll.find(plan.filter);
+      if (plan.projection) cursor = cursor.project(plan.projection);
+      if (plan.sort) cursor = cursor.sort(plan.sort);
+      if (plan.limit !== void 0) cursor = cursor.limit(plan.limit);
+      return cursor.toArray();
+    }
+    return coll.aggregate(plan.pipeline).toArray();
+  }
+  async fetch() {
+    if (!this.collection) {
+      this.error = "Mongo collection not initialized";
+      return;
+    }
+    try {
+      const filter = this.config.filter ?? {};
+      const docs = await this.collection.find(filter).limit(this.maxRows + 1).toArray();
+      if (docs.length > this.maxRows) {
+        throw new Error(
+          `Query returned more than maxRows=${this.maxRows}. Tighten the filter, or raise maxRows in the source config.`
+        );
+      }
+      this.data = docs.map((d) => {
+        const { _id, ...rest } = d;
+        return rest;
+      });
+      this.lastFetch = /* @__PURE__ */ new Date();
+      this.error = void 0;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb(this.data);
+  }
+};
+
+// src/server/sources/manager.ts
+var SourceManager = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  sources = /* @__PURE__ */ new Map();
+  globalListeners = /* @__PURE__ */ new Set();
+  async addSource(name, config) {
+    if (this.sources.has(name)) {
+      this.removeSource(name);
+    }
+    const adapter = this.createAdapter(config);
+    const entry = { config, adapter };
+    entry.unsubscribe = adapter.onUpdate((data) => {
+      for (const listener of this.globalListeners) {
+        listener(name, data);
+      }
+    });
+    this.sources.set(name, entry);
+    await adapter.start();
+  }
+  removeSource(name) {
+    const entry = this.sources.get(name);
+    if (!entry) return false;
+    entry.unsubscribe?.();
+    entry.adapter.stop();
+    this.sources.delete(name);
+    return true;
+  }
+  getContext() {
+    const ctx = {};
+    for (const [name, { adapter }] of this.sources) {
+      ctx[name] = adapter.getData();
+    }
+    return ctx;
+  }
+  getSourceData(name) {
+    return this.sources.get(name)?.adapter.getData();
+  }
+  getSourceStatus(name) {
+    return this.sources.get(name)?.adapter.getStatus();
+  }
+  getAllStatuses() {
+    const result = {};
+    for (const [name, { adapter }] of this.sources) {
+      result[name] = adapter.getStatus();
+    }
+    return result;
+  }
+  getSourceNames() {
+    return [...this.sources.keys()];
+  }
+  /**
+   * Subscribe to data updates from any source.
+   * Used by SSE endpoint for real-time push to TUI clients.
+   * Returns unsubscribe function.
+   */
+  onSourceUpdate(callback) {
+    this.globalListeners.add(callback);
+    return () => this.globalListeners.delete(callback);
+  }
+  async refreshAll() {
+    await Promise.all(
+      [...this.sources.values()].map(({ adapter }) => adapter.refresh?.() ?? Promise.resolve())
+    );
+  }
+  /**
+   * Run a pipe expression, preferring adapter-native push-down when the
+   * source supports it.
+   *
+   * Decision tree:
+   *   1. Parse the expression. If it can't parse, fall straight through to
+   *      the in-process engine, which will throw the same parse error a
+   *      caller would have seen before push-down existed (no behaviour
+   *      change for malformed input).
+   *   2. Look up the source named in the pipeline. If it exists and its
+   *      adapter exposes `runPushdown`, try it. On `{ ok: true }` we're
+   *      done — return the rows. On `{ ok: false }` (decline) or any
+   *      thrown error, fall back to in-process.
+   *   3. In-process: query(getContext(), expression) — the existing path.
+   *
+   * The push-down attempt is best-effort and *invisible to callers*: same
+   * return type as `query()`, no new failure modes. Telemetry (which
+   * branch ran, latency, source-engine SQL) belongs in the audit log when
+   * Phase 5 lands; not threaded through here.
+   */
+  async runQuery(expression) {
+    const pushed = await this.tryPushdown(expression);
+    if (pushed && pushed.ok) return pushed.rows;
+    return query(this.getContext(), expression);
+  }
+  /**
+   * Inspect the pipeline AST and dispatch to an adapter's runPushdown when
+   * eligible. Returns `null` when push-down isn't even attempted (no parse,
+   * no source, no capability). Returns a PushdownResult when it was tried —
+   * `{ ok: true }` for success, `{ ok: false, reason }` for decline.
+   *
+   * Exposed on the manager (rather than tucked inside runQuery) so the
+   * future `event.audit` channel can record `pushed_down: bool` and the
+   * `source_engine_query` SQL string for governance. Today only Postgres
+   * implements runPushdown; MySQL / SQLite / ClickHouse will follow the
+   * same interface.
+   */
+  async tryPushdown(expression) {
+    let pipeline;
+    try {
+      pipeline = parseQuery(expression);
+    } catch {
+      return null;
+    }
+    const entry = this.sources.get(pipeline.source);
+    if (!entry) return null;
+    if (!entry.adapter.runPushdown) return null;
+    try {
+      return await entry.adapter.runPushdown(expression);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return { ok: false, reason: `pushdown threw: ${reason}` };
+    }
+  }
+  async dispose() {
+    this.globalListeners.clear();
+    for (const entry of this.sources.values()) {
+      entry.unsubscribe?.();
+      entry.adapter.stop();
+    }
+    this.sources.clear();
+  }
+  createAdapter(config) {
+    switch (config.type) {
+      case "rest":
+        return new RestSourceAdapter(config);
+      case "websocket":
+        return new WebSocketSourceAdapter(config);
+      case "file":
+        return new FileSourceAdapter(config, this.cwd);
+      case "static":
+        return new StaticSourceAdapter(config);
+      case "postgres":
+        return new PostgresSourceAdapter(config);
+      case "mysql":
+        return new MysqlSourceAdapter(config);
+      case "sqlite":
+        return new SqliteSourceAdapter(config, this.cwd);
+      case "kafka":
+        return new KafkaSourceAdapter(config);
+      case "snowflake":
+        return new SnowflakeSourceAdapter(config);
+      case "clickhouse":
+        return new ClickhouseSourceAdapter(config);
+      case "mongodb":
+        return new MongoSourceAdapter(config);
+      default:
+        throw new Error(`Unknown source type: ${config.type}`);
+    }
+  }
+};
+export {
+  SourceManager
+};