@vaultgradient/pipequery-cli 0.3.2

package/dist/index.js

@@ -0,0 +1,4630 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+
+// src/commands/init.ts
+import { writeFile } from "fs/promises";
+import { resolve } from "path";
+import { existsSync } from "fs";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  info: (msg) => console.log(chalk.hex("#06b6d4")("  \u25CF"), msg),
+  success: (msg) => console.log(chalk.hex("#10b981")("  \u2713"), msg),
+  warn: (msg) => console.log(chalk.hex("#f59e0b")("  \u26A0"), msg),
+  error: (msg) => console.error(chalk.hex("#ef4444")("  \u2717"), msg),
+  dim: (msg) => console.log(chalk.dim(`    ${msg}`)),
+  step: (msg) => console.log(chalk.hex("#4f46e5")("  \u2192"), msg)
+};
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  server: {
+    port: 3e3,
+    host: "0.0.0.0"
+  },
+  sources: {},
+  endpoints: {},
+  dashboards: {}
+};
+var STARTER_YAML = `# PipeQuery Configuration
+# Docs: https://github.com/andreadito/pipequery
+
+server:
+  port: 3000
+  host: 0.0.0.0
+
+# Data sources \u2014 REST APIs, WebSockets, files, or inline JSON
+sources:
+  # Example: crypto prices from CoinCap
+  # crypto:
+  #   type: rest
+  #   url: https://api.coincap.io/v2/assets
+  #   dataPath: data
+  #   interval: 30s
+  #
+  # orders:
+  #   type: file
+  #   path: ./data/orders.csv
+  #   watch: true
+
+# API endpoints \u2014 expose PipeQuery results as REST APIs
+endpoints: {}
+  # /api/top-coins:
+  #   query: "crypto | sort(market_cap desc) | first(10)"
+  #   cache: 30s
+
+# Terminal dashboards
+dashboards: {}
+  # main:
+  #   refresh: 10s
+  #   panels:
+  #     - title: Top Assets
+  #       query: "crypto | sort(market_cap desc) | first(10)"
+  #       viz: table
+`;
+
+// src/commands/init.ts
+import chalk2 from "chalk";
+async function initCommand() {
+  const target = resolve(process.cwd(), "pipequery.yaml");
+  if (existsSync(target)) {
+    log.warn("pipequery.yaml already exists in this directory.");
+    return;
+  }
+  await writeFile(target, STARTER_YAML, "utf-8");
+  log.success("Created pipequery.yaml");
+  log.step(`Edit ${chalk2.white.bold("pipequery.yaml")} to configure your data sources`);
+  log.step(`Then run ${chalk2.white.bold("pq serve")} to start the server`);
+}
+
+// src/commands/serve.ts
+import { writeFile as writeFile3, mkdir, readFile as readFile3, unlink } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { spawn } from "child_process";
+
+// src/config/loader.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/utils/yaml.ts
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+import YAML from "yaml";
+async function readYaml(path) {
+  const content = await readFile(path, "utf-8");
+  return YAML.parse(content);
+}
+async function writeYaml(path, data) {
+  const content = YAML.stringify(data, { lineWidth: 120 });
+  await writeFile2(path, content, "utf-8");
+}
+
+// src/config/loader.ts
+var CONFIG_NAMES = ["pipequery.yaml", "pipequery.yml"];
+function findConfigPath(cwd = process.cwd()) {
+  for (const name of CONFIG_NAMES) {
+    const p = resolve2(cwd, name);
+    if (existsSync2(p)) return p;
+  }
+  return null;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = findConfigPath(cwd);
+  if (!configPath) {
+    throw new Error("No pipequery.yaml found. Run `pq init` to create one.");
+  }
+  const raw = await readYaml(configPath);
+  const config = {
+    server: { ...DEFAULT_CONFIG.server, ...raw.server },
+    remote: raw.remote,
+    sources: raw.sources ?? {},
+    endpoints: raw.endpoints ?? {},
+    dashboards: raw.dashboards ?? {}
+  };
+  return { config, path: configPath };
+}
+async function saveConfig(config, configPath) {
+  await writeYaml(configPath, config);
+}
+
+// src/server/app.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+
+// 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/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 = this.config.url;
+      if (this.config.params) {
+        const params = new URLSearchParams(this.config.params);
+        url += (url.includes("?") ? "&" : "?") + params.toString();
+      }
+      const res = await globalThis.fetch(url, {
+        headers: this.config.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);
+  }
+};
+
+// 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;
+  async start() {
+    return new Promise((resolve9, reject) => {
+      this.ws = new WebSocket(this.config.url);
+      this.ws.on("open", () => {
+        this.error = void 0;
+        resolve9();
+      });
+      this.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 {
+        }
+      });
+      this.ws.on("error", (err) => {
+        this.error = err.message;
+        reject(err);
+      });
+      this.ws.on("close", () => {
+        setTimeout(() => {
+          if (this.ws) this.start().catch(() => {
+          });
+        }, 5e3);
+      });
+    });
+  }
+  stop() {
+    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);
+  }
+};
+
+// src/server/sources/file.ts
+import { readFile as readFile2 } from "fs/promises";
+import { extname, resolve as resolve3 } 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 = resolve3(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 readFile2(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/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())
+    );
+  }
+  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);
+      default:
+        throw new Error(`Unknown source type: ${config.type}`);
+    }
+  }
+};
+
+// src/server/routes/health.ts
+function registerHealthRoutes(app, sourceManager, startedAt) {
+  app.get("/health", async () => {
+    return { status: "ok", uptime: Date.now() - startedAt.getTime() };
+  });
+  app.get("/status", async () => {
+    return {
+      status: "ok",
+      uptime: Date.now() - startedAt.getTime(),
+      sources: sourceManager.getAllStatuses()
+    };
+  });
+}
+
+// ../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(source2) {
+  const tokens = [];
+  let pos = 0;
+  let line = 1;
+  let column = 1;
+  function advance() {
+    const ch = source2[pos];
+    pos++;
+    if (ch === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+    return ch;
+  }
+  function peek() {
+    return source2[pos];
+  }
+  function peekNext() {
+    return source2[pos + 1];
+  }
+  function addToken(type, value, startPos, startLine, startCol) {
+    tokens.push({ type, value, position: startPos, line: startLine, column: startCol });
+  }
+  function error2(msg) {
+    throw new LexerError(msg, pos, line, column);
+  }
+  while (pos < source2.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 < source2.length && peek() >= "0" && peek() <= "9") advance();
+      if (pos < source2.length && peek() === "." && pos + 1 < source2.length && source2[pos + 1] >= "0" && source2[pos + 1] <= "9") {
+        advance();
+        while (pos < source2.length && peek() >= "0" && peek() <= "9") advance();
+      }
+      addToken("NUMBER", source2.slice(start, pos), startPos, startLine, startCol);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      advance();
+      const start = pos;
+      let value = "";
+      while (pos < source2.length && peek() !== quote) {
+        if (peek() === "\\" && pos + 1 < source2.length) {
+          advance();
+          const escaped = advance();
+          if (escaped === "n") value += "\n";
+          else if (escaped === "t") value += "	";
+          else value += escaped;
+        } else {
+          value += advance();
+        }
+      }
+      if (pos >= source2.length) {
+        error2(`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 < source2.length && (peek() >= "a" && peek() <= "z" || peek() >= "A" && peek() <= "Z" || peek() >= "0" && peek() <= "9" || peek() === "_")) {
+        advance();
+      }
+      const word = source2.slice(start, pos);
+      const keywordType = KEYWORDS[word];
+      if (keywordType) {
+        addToken(keywordType, word, startPos, startLine, startCol);
+      } else {
+        addToken("IDENTIFIER", word, startPos, startLine, startCol);
+      }
+      continue;
+    }
+    error2(`Unexpected character '${ch}'`);
+  }
+  addToken("EOF", "", pos, line, column);
+  return tokens;
+}
+
+// ../src/engine/parser.ts
+function parse(tokens) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function advance() {
+    const token = tokens[pos];
+    pos++;
+    return token;
+  }
+  function expect(type, context) {
+    const token = peek();
+    if (token.type !== type) {
+      const ctx = context ? ` ${context}` : "";
+      throw new ParseError(
+        `Expected ${type} but found ${token.type} ('${token.value}')${ctx}`,
+        token.position,
+        token.line,
+        token.column
+      );
+    }
+    return advance();
+  }
+  function match(type) {
+    if (peek().type === type) {
+      advance();
+      return true;
+    }
+    return false;
+  }
+  function parseExpression() {
+    let expr = parseOrExpr();
+    if (peek().type === "AS") {
+      advance();
+      const nameToken = expect("IDENTIFIER", 'after "as"');
+      expr = { kind: "AliasExpr", expression: expr, alias: nameToken.value };
+    }
+    return expr;
+  }
+  function parseOrExpr() {
+    let left = parseAndExpr();
+    while (peek().type === "OR") {
+      advance();
+      const right = parseAndExpr();
+      left = { kind: "BinaryExpr", operator: "||", left, right };
+    }
+    return left;
+  }
+  function parseAndExpr() {
+    let left = parseEqualityExpr();
+    while (peek().type === "AND") {
+      advance();
+      const right = parseEqualityExpr();
+      left = { kind: "BinaryExpr", operator: "&&", left, right };
+    }
+    return left;
+  }
+  function parseEqualityExpr() {
+    let left = parseComparisonExpr();
+    while (peek().type === "EQ" || peek().type === "NEQ") {
+      const op = advance().value;
+      const right = parseComparisonExpr();
+      left = { kind: "BinaryExpr", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseComparisonExpr() {
+    let left = parseAdditiveExpr();
+    while (peek().type === "GT" || peek().type === "GTE" || peek().type === "LT" || peek().type === "LTE") {
+      const op = advance().value;
+      const right = parseAdditiveExpr();
+      left = { kind: "BinaryExpr", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseAdditiveExpr() {
+    let left = parseMultiplicativeExpr();
+    while (peek().type === "PLUS" || peek().type === "MINUS") {
+      const op = advance().value;
+      const right = parseMultiplicativeExpr();
+      left = { kind: "BinaryExpr", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseMultiplicativeExpr() {
+    let left = parseUnaryExpr();
+    while (peek().type === "STAR" || peek().type === "SLASH" || peek().type === "MOD") {
+      const op = advance().value;
+      const right = parseUnaryExpr();
+      left = { kind: "BinaryExpr", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseUnaryExpr() {
+    if (peek().type === "NOT") {
+      advance();
+      const operand = parseUnaryExpr();
+      return { kind: "UnaryExpr", operator: "!", operand };
+    }
+    if (peek().type === "MINUS") {
+      advance();
+      const operand = parseUnaryExpr();
+      return { kind: "UnaryExpr", operator: "-", operand };
+    }
+    return parsePrimaryExpr();
+  }
+  function parsePrimaryExpr() {
+    const token = peek();
+    if (token.type === "NUMBER") {
+      advance();
+      return { kind: "NumberLiteral", value: Number(token.value) };
+    }
+    if (token.type === "STRING") {
+      advance();
+      return { kind: "StringLiteral", value: token.value };
+    }
+    if (token.type === "BOOLEAN") {
+      advance();
+      return { kind: "BooleanLiteral", value: token.value === "true" };
+    }
+    if (token.type === "NULL") {
+      advance();
+      return { kind: "NullLiteral" };
+    }
+    if (token.type === "IDENTIFIER") {
+      advance();
+      const name = token.value;
+      if (peek().type === "LPAREN") {
+        advance();
+        const args = [];
+        if (peek().type !== "RPAREN") {
+          args.push(parseExpression());
+          while (match("COMMA")) {
+            args.push(parseExpression());
+          }
+        }
+        expect("RPAREN", "after function arguments");
+        return { kind: "FunctionCall", name, args };
+      }
+      const path = [name];
+      while (peek().type === "DOT") {
+        advance();
+        const next = expect("IDENTIFIER", 'after "."');
+        path.push(next.value);
+      }
+      return { kind: "FieldAccess", path };
+    }
+    if (token.type === "LPAREN") {
+      advance();
+      const expr = parseExpression();
+      expect("RPAREN", "after grouped expression");
+      return expr;
+    }
+    throw new ParseError(
+      `Unexpected token ${token.type} ('${token.value}')`,
+      token.position,
+      token.line,
+      token.column
+    );
+  }
+  function isAggregateExpression(expr) {
+    if (expr.kind === "AliasExpr") return isAggregateExpression(expr.expression);
+    if (expr.kind === "FunctionCall") return AGGREGATE_NAMES.has(expr.name);
+    return false;
+  }
+  function parseOperation() {
+    const nameToken = expect("IDENTIFIER", 'after "|"');
+    const name = nameToken.value;
+    expect("LPAREN", `after "${name}"`);
+    let op;
+    switch (name) {
+      case "where": {
+        const condition = parseExpression();
+        op = { kind: "WhereOp", condition };
+        break;
+      }
+      case "select": {
+        const fields = [];
+        if (peek().type !== "RPAREN") {
+          fields.push(parseExpression());
+          while (match("COMMA")) {
+            fields.push(parseExpression());
+          }
+        }
+        op = { kind: "SelectOp", fields };
+        break;
+      }
+      case "sort": {
+        const criteria = [];
+        if (peek().type !== "RPAREN") {
+          const expr = parseOrExpr();
+          let direction = "asc";
+          if (peek().type === "ASC") {
+            advance();
+            direction = "asc";
+          } else if (peek().type === "DESC") {
+            advance();
+            direction = "desc";
+          }
+          criteria.push({ expression: expr, direction });
+          while (match("COMMA")) {
+            const e = parseOrExpr();
+            let d = "asc";
+            if (peek().type === "ASC") {
+              advance();
+              d = "asc";
+            } else if (peek().type === "DESC") {
+              advance();
+              d = "desc";
+            }
+            criteria.push({ expression: e, direction: d });
+          }
+        }
+        op = { kind: "SortOp", criteria };
+        break;
+      }
+      case "groupBy": {
+        const keys = [];
+        if (peek().type !== "RPAREN") {
+          keys.push(parseOrExpr());
+          while (match("COMMA")) {
+            keys.push(parseOrExpr());
+          }
+        }
+        op = { kind: "GroupByOp", keys };
+        break;
+      }
+      case "join": {
+        const rightToken = expect("IDENTIFIER", "for join source");
+        const right = rightToken.value;
+        expect("COMMA", "after join source");
+        const condition = parseExpression();
+        op = { kind: "JoinOp", right, condition };
+        break;
+      }
+      case "first": {
+        const numToken = expect("NUMBER", "for first count");
+        op = { kind: "FirstOp", count: Number(numToken.value) };
+        break;
+      }
+      case "last": {
+        const numToken = expect("NUMBER", "for last count");
+        op = { kind: "LastOp", count: Number(numToken.value) };
+        break;
+      }
+      case "distinct": {
+        const fields = [];
+        if (peek().type !== "RPAREN") {
+          fields.push(parseOrExpr());
+          while (match("COMMA")) {
+            fields.push(parseOrExpr());
+          }
+        }
+        op = { kind: "DistinctOp", fields: fields.length > 0 ? fields : void 0 };
+        break;
+      }
+      case "flatten": {
+        let field;
+        if (peek().type !== "RPAREN") {
+          field = parseOrExpr();
+        }
+        op = { kind: "FlattenOp", field };
+        break;
+      }
+      case "transpose": {
+        let headerField;
+        if (peek().type !== "RPAREN") {
+          headerField = parseOrExpr();
+        }
+        op = { kind: "TransposeOp", headerField };
+        break;
+      }
+      case "rollup": {
+        const keys = [];
+        const aggregates = [];
+        let seenAggregate = false;
+        if (peek().type !== "RPAREN") {
+          const expr = parseExpression();
+          if (isAggregateExpression(expr)) {
+            seenAggregate = true;
+            aggregates.push(expr);
+          } else {
+            keys.push(expr);
+          }
+          while (match("COMMA")) {
+            const e = parseExpression();
+            if (isAggregateExpression(e)) {
+              seenAggregate = true;
+              aggregates.push(e);
+            } else if (seenAggregate) {
+              const t = peek();
+              throw new ParseError(
+                "rollup: group keys must come before aggregate expressions",
+                t.position,
+                t.line,
+                t.column
+              );
+            } else {
+              keys.push(e);
+            }
+          }
+        }
+        if (aggregates.length === 0) {
+          const t = peek();
+          throw new ParseError(
+            "rollup: at least one aggregate expression is required",
+            t.position,
+            t.line,
+            t.column
+          );
+        }
+        op = { kind: "RollupOp", keys, aggregates };
+        break;
+      }
+      case "pivot": {
+        const pivotField = parseOrExpr();
+        expect("COMMA", "after pivot field");
+        const aggregates = [];
+        aggregates.push(parseExpression());
+        while (match("COMMA")) {
+          aggregates.push(parseExpression());
+        }
+        op = { kind: "PivotOp", pivotField, aggregates };
+        break;
+      }
+      case "map": {
+        const fields = [];
+        if (peek().type !== "RPAREN") {
+          fields.push(parseExpression());
+          while (match("COMMA")) {
+            fields.push(parseExpression());
+          }
+        }
+        op = { kind: "MapOp", fields };
+        break;
+      }
+      case "reduce": {
+        const initial = parseExpression();
+        expect("COMMA", "after reduce initial value");
+        const accumulator = parseExpression();
+        op = { kind: "ReduceOp", initial, accumulator };
+        break;
+      }
+      default: {
+        if (AGGREGATE_NAMES.has(name)) {
+          if (TWO_ARG_AGGREGATES.has(name)) {
+            const args = [];
+            args.push(parseOrExpr());
+            expect("COMMA", `after first argument of ${name}`);
+            args.push(parseOrExpr());
+            op = { kind: "AggregateOp", function: name, args };
+          } else {
+            let field;
+            if (peek().type !== "RPAREN") {
+              field = parseOrExpr();
+            }
+            op = { kind: "AggregateOp", function: name, field };
+          }
+          break;
+        }
+        throw new ParseError(
+          `Unknown operation "${name}"`,
+          nameToken.position,
+          nameToken.line,
+          nameToken.column
+        );
+      }
+    }
+    expect("RPAREN", `after ${name} arguments`);
+    return op;
+  }
+  function parsePipeline() {
+    const sourceToken = expect("IDENTIFIER", "at start of pipeline");
+    const operations = [];
+    while (peek().type === "PIPE") {
+      advance();
+      operations.push(parseOperation());
+    }
+    if (peek().type !== "EOF") {
+      const t = peek();
+      throw new ParseError(
+        `Unexpected token ${t.type} ('${t.value}') after pipeline`,
+        t.position,
+        t.line,
+        t.column
+      );
+    }
+    return { kind: "Pipeline", source: sourceToken.value, operations };
+  }
+  return parsePipeline();
+}
+
+// ../src/engine/runtime.ts
+var accessorCache = /* @__PURE__ */ new Map();
+function getFieldAccessor(path) {
+  const key = path.join(".");
+  let fn = accessorCache.get(key);
+  if (fn) return fn;
+  if (path.length === 1) {
+    const field = path[0];
+    fn = (obj) => obj[field];
+  } else {
+    const segments = [...path];
+    fn = (obj) => {
+      let val = obj;
+      for (const segment of segments) {
+        if (val == null) return void 0;
+        val = val[segment];
+      }
+      return val;
+    };
+  }
+  accessorCache.set(key, fn);
+  return fn;
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  return String(a).localeCompare(String(b));
+}
+function groupByFn(data, keyFns) {
+  const groups = /* @__PURE__ */ new Map();
+  if (keyFns.length === 1) {
+    const { fn, name } = keyFns[0];
+    for (const row of data) {
+      const val = fn(row);
+      const groupKey = String(val);
+      let group = groups.get(groupKey);
+      if (!group) {
+        group = { keys: { [name]: val }, rows: [] };
+        groups.set(groupKey, group);
+      }
+      group.rows.push(row);
+    }
+  } else {
+    for (const row of data) {
+      const keys = {};
+      let groupKey = "";
+      for (let i = 0; i < keyFns.length; i++) {
+        const { fn, name } = keyFns[i];
+        const val = fn(row);
+        keys[name] = val;
+        groupKey += (i > 0 ? "\0" : "") + String(val);
+      }
+      let group = groups.get(groupKey);
+      if (!group) {
+        group = { keys, rows: [] };
+        groups.set(groupKey, group);
+      }
+      group.rows.push(row);
+    }
+  }
+  return Array.from(groups.values());
+}
+function nestedLoopJoin(left, right, conditionFn) {
+  const result = [];
+  for (const l of left) {
+    for (const r of right) {
+      const combined = { ...l, ...r };
+      if (conditionFn(combined)) {
+        result.push(combined);
+      }
+    }
+  }
+  return result;
+}
+function hashJoin(left, right, leftKeyFn, rightKeyFn) {
+  const hashMap = /* @__PURE__ */ new Map();
+  for (const r of right) {
+    const key = rightKeyFn(r);
+    let bucket = hashMap.get(key);
+    if (!bucket) {
+      bucket = [];
+      hashMap.set(key, bucket);
+    }
+    bucket.push(r);
+  }
+  const result = [];
+  for (const l of left) {
+    const matches = hashMap.get(leftKeyFn(l));
+    if (matches) {
+      for (const r of matches) {
+        result.push({ ...l, ...r });
+      }
+    }
+  }
+  return result;
+}
+function distinctFn(data, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return data.filter((row) => {
+    const key = keyFn ? keyFn(row) : JSON.stringify(row);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function transposeFn(data, headerFn, headerFieldName) {
+  if (data.length === 0) return [];
+  const colNames = data.map(
+    (row, i) => headerFn ? String(headerFn(row)) : `col_${i}`
+  );
+  const allFields = /* @__PURE__ */ new Set();
+  for (const row of data) {
+    for (const key of Object.keys(row)) {
+      if (key !== "_group" && key !== headerFieldName) {
+        allFields.add(key);
+      }
+    }
+  }
+  const results = [];
+  for (const field of allFields) {
+    const row = { _field: field };
+    for (let i = 0; i < data.length; i++) {
+      row[colNames[i]] = data[i][field] ?? null;
+    }
+    results.push(row);
+  }
+  return results;
+}
+function rollupFn(data, keyFns, aggFns) {
+  const results = [];
+  const numKeys = keyFns.length;
+  for (let level = 0; level <= numKeys; level++) {
+    const activeKeys = keyFns.slice(0, numKeys - level);
+    const groups = groupByFn(data, activeKeys);
+    for (const group of groups) {
+      const row = {};
+      for (const { name } of activeKeys) {
+        row[name] = group.keys[name];
+      }
+      for (let i = numKeys - level; i < numKeys; i++) {
+        row[keyFns[i].name] = null;
+      }
+      const groupedRow = { ...row, _group: group.rows };
+      for (const { fn, name } of aggFns) {
+        row[name] = fn(groupedRow);
+      }
+      row._rollupLevel = level;
+      results.push(row);
+    }
+  }
+  return results;
+}
+function defaultForAggregate(name) {
+  if (name === "min" || name === "max") return null;
+  return 0;
+}
+function pivotFlatFn(data, pivotFn, aggCompilers, singleAggregate) {
+  const pivotGroups = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const pivotVal = String(pivotFn(row));
+    if (!pivotGroups.has(pivotVal)) pivotGroups.set(pivotVal, []);
+    pivotGroups.get(pivotVal).push(row);
+  }
+  const result = {};
+  for (const [pivotVal, groupRows] of pivotGroups) {
+    const syntheticRow = { _group: groupRows };
+    const safeName = pivotVal.replace(/\s+/g, "_");
+    for (const { fn, name } of aggCompilers) {
+      const colName = singleAggregate ? safeName : `${name}_${safeName}`;
+      result[colName] = fn(syntheticRow);
+    }
+  }
+  return [result];
+}
+function pivotGroupedFn(data, pivotFn, aggCompilers, singleAggregate) {
+  const allPivotValues = /* @__PURE__ */ new Set();
+  for (const groupRow of data) {
+    const groupData = groupRow._group;
+    for (const row of groupData) {
+      allPivotValues.add(String(pivotFn(row)));
+    }
+  }
+  return data.map((groupRow) => {
+    const groupData = groupRow._group;
+    const result = {};
+    for (const key of Object.keys(groupRow)) {
+      if (key !== "_group") result[key] = groupRow[key];
+    }
+    const subGroups = /* @__PURE__ */ new Map();
+    for (const row of groupData) {
+      const pivotVal = String(pivotFn(row));
+      if (!subGroups.has(pivotVal)) subGroups.set(pivotVal, []);
+      subGroups.get(pivotVal).push(row);
+    }
+    for (const pivotVal of allPivotValues) {
+      const subGroupRows = subGroups.get(pivotVal) || [];
+      const syntheticRow = { _group: subGroupRows };
+      const safeName = pivotVal.replace(/\s+/g, "_");
+      for (const { fn, name } of aggCompilers) {
+        const colName = singleAggregate ? safeName : `${name}_${safeName}`;
+        result[colName] = subGroupRows.length > 0 ? fn(syntheticRow) : defaultForAggregate(name);
+      }
+    }
+    return result;
+  });
+}
+function computeWindowValues(data, windowDefs) {
+  const n = data.length;
+  const results = Array.from({ length: n }, () => ({}));
+  for (const def of windowDefs) {
+    switch (def.name) {
+      case "row_number":
+      case "running_count":
+        for (let i = 0; i < n; i++) results[i][def.id] = i + 1;
+        break;
+      case "running_sum": {
+        let acc = 0;
+        for (let i = 0; i < n; i++) {
+          acc += Number(def.fieldFn(data[i]));
+          results[i][def.id] = acc;
+        }
+        break;
+      }
+      case "running_avg": {
+        let acc = 0;
+        for (let i = 0; i < n; i++) {
+          acc += Number(def.fieldFn(data[i]));
+          results[i][def.id] = acc / (i + 1);
+        }
+        break;
+      }
+      case "running_min": {
+        let min = Infinity;
+        for (let i = 0; i < n; i++) {
+          const val = Number(def.fieldFn(data[i]));
+          if (val < min) min = val;
+          results[i][def.id] = min;
+        }
+        break;
+      }
+      case "running_max": {
+        let max = -Infinity;
+        for (let i = 0; i < n; i++) {
+          const val = Number(def.fieldFn(data[i]));
+          if (val > max) max = val;
+          results[i][def.id] = max;
+        }
+        break;
+      }
+      case "lag": {
+        const offset = def.offset;
+        for (let i = 0; i < n; i++) {
+          results[i][def.id] = i >= offset ? def.fieldFn(data[i - offset]) : null;
+        }
+        break;
+      }
+      case "lead": {
+        const offset = def.offset;
+        for (let i = 0; i < n; i++) {
+          results[i][def.id] = i + offset < n ? def.fieldFn(data[i + offset]) : null;
+        }
+        break;
+      }
+    }
+  }
+  return results;
+}
+
+// ../src/engine/compiler.ts
+function computeMedian(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function computePercentile(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = p / 100 * (sorted.length - 1);
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+}
+function computeVariance(values) {
+  if (values.length === 0) return 0;
+  const mean = values.reduce((a, b) => a + b, 0) / values.length;
+  return values.reduce((acc, v) => acc + (v - mean) ** 2, 0) / values.length;
+}
+function computeStddev(values) {
+  return Math.sqrt(computeVariance(values));
+}
+function computeSkew(values) {
+  const n = values.length;
+  if (n < 3) return 0;
+  const mean = values.reduce((a, b) => a + b, 0) / n;
+  const sd = computeStddev(values);
+  if (sd === 0) return 0;
+  return values.reduce((acc, v) => acc + ((v - mean) / sd) ** 3, 0) / n;
+}
+function computeKurt(values) {
+  const n = values.length;
+  if (n < 4) return 0;
+  const mean = values.reduce((a, b) => a + b, 0) / n;
+  const sd = computeStddev(values);
+  if (sd === 0) return 0;
+  return values.reduce((acc, v) => acc + ((v - mean) / sd) ** 4, 0) / n - 3;
+}
+function computeDrawdown(values) {
+  if (values.length === 0) return 0;
+  let peak = values[0];
+  let maxDd = 0;
+  for (const v of values) {
+    if (v > peak) peak = v;
+    const dd = peak === 0 ? 0 : (v - peak) / peak;
+    if (dd < maxDd) maxDd = dd;
+  }
+  return maxDd;
+}
+function computeDownsideDeviation(values, target = 0) {
+  if (values.length === 0) return 0;
+  const downside = values.filter((v) => v < target).map((v) => (v - target) ** 2);
+  if (downside.length === 0) return 0;
+  return Math.sqrt(downside.reduce((a, b) => a + b, 0) / values.length);
+}
+var WINDOW_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  "running_sum",
+  "running_avg",
+  "running_count",
+  "running_min",
+  "running_max",
+  "row_number",
+  "lag",
+  "lead"
+]);
+var windowIdCounter = 0;
+function compileExpression(expr, grouped = false) {
+  switch (expr.kind) {
+    case "NumberLiteral": {
+      const v = expr.value;
+      return () => v;
+    }
+    case "StringLiteral": {
+      const v = expr.value;
+      return () => v;
+    }
+    case "BooleanLiteral": {
+      const v = expr.value;
+      return () => v;
+    }
+    case "NullLiteral":
+      return () => null;
+    case "FieldAccess": {
+      const accessor = getFieldAccessor(expr.path);
+      return accessor;
+    }
+    case "BinaryExpr": {
+      const leftFn = compileExpression(expr.left, grouped);
+      const rightFn = compileExpression(expr.right, grouped);
+      const op = expr.operator;
+      switch (op) {
+        case ">":
+          return (row) => leftFn(row) > rightFn(row);
+        case ">=":
+          return (row) => leftFn(row) >= rightFn(row);
+        case "<":
+          return (row) => leftFn(row) < rightFn(row);
+        case "<=":
+          return (row) => leftFn(row) <= rightFn(row);
+        case "==":
+          return (row) => leftFn(row) === rightFn(row);
+        case "!=":
+          return (row) => leftFn(row) !== rightFn(row);
+        case "&&":
+          return (row) => leftFn(row) && rightFn(row);
+        case "||":
+          return (row) => leftFn(row) || rightFn(row);
+        case "+":
+          return (row) => leftFn(row) + rightFn(row);
+        case "-":
+          return (row) => leftFn(row) - rightFn(row);
+        case "*":
+          return (row) => leftFn(row) * rightFn(row);
+        case "/":
+          return (row) => leftFn(row) / rightFn(row);
+        case "%":
+          return (row) => leftFn(row) % rightFn(row);
+      }
+      break;
+    }
+    case "UnaryExpr": {
+      const operandFn = compileExpression(expr.operand, grouped);
+      if (expr.operator === "!") return (row) => !operandFn(row);
+      return (row) => -operandFn(row);
+    }
+    case "FunctionCall":
+      return compileFunctionCall(expr, grouped);
+    case "AliasExpr":
+      return compileExpression(expr.expression, grouped);
+  }
+  throw new RuntimeError(`Unknown expression kind: ${expr.kind}`);
+}
+function compileFunctionCall(expr, grouped) {
+  const { name, args } = expr;
+  if (grouped && AGGREGATE_NAMES.has(name)) {
+    return compileGroupAggregate(name, args);
+  }
+  if (WINDOW_FUNCTION_NAMES.has(name)) {
+    const id = `_w${windowIdCounter++}`;
+    const fieldFn = args.length > 0 ? compileExpression(args[0], false) : void 0;
+    const offset = args.length > 1 ? args[1].value || 1 : 1;
+    const fn = ((row) => {
+      const ctx = row._windowCtx;
+      return ctx?.[id];
+    });
+    fn._windowDef = { id, name, fieldFn, offset };
+    return fn;
+  }
+  switch (name) {
+    case "if": {
+      if (args.length < 2 || args.length > 3) {
+        throw new RuntimeError(`if() expects 2 or 3 arguments, got ${args.length}`);
+      }
+      const condFn = compileExpression(args[0], grouped);
+      const thenFn = compileExpression(args[1], grouped);
+      const elseFn = args.length === 3 ? compileExpression(args[2], grouped) : () => null;
+      return (row) => condFn(row) ? thenFn(row) : elseFn(row);
+    }
+    case "coalesce": {
+      const fns = args.map((a) => compileExpression(a, grouped));
+      return (row) => {
+        for (const fn of fns) {
+          const val = fn(row);
+          if (val != null) return val;
+        }
+        return null;
+      };
+    }
+    case "lower": {
+      const fn = compileExpression(args[0], grouped);
+      return (row) => String(fn(row)).toLowerCase();
+    }
+    case "upper": {
+      const fn = compileExpression(args[0], grouped);
+      return (row) => String(fn(row)).toUpperCase();
+    }
+    case "len": {
+      const fn = compileExpression(args[0], grouped);
+      return (row) => {
+        const val = fn(row);
+        if (Array.isArray(val)) return val.length;
+        if (typeof val === "string") return val.length;
+        return 0;
+      };
+    }
+    case "abs": {
+      const fn = compileExpression(args[0], grouped);
+      return (row) => Math.abs(fn(row));
+    }
+    case "round": {
+      const fn = compileExpression(args[0], grouped);
+      const precFn = args.length > 1 ? compileExpression(args[1], grouped) : () => 0;
+      return (row) => {
+        const val = fn(row);
+        const prec = precFn(row);
+        const factor = Math.pow(10, prec);
+        return Math.round(val * factor) / factor;
+      };
+    }
+    case "concat": {
+      const fns = args.map((a) => compileExpression(a, grouped));
+      return (row) => fns.map((fn) => String(fn(row))).join("");
+    }
+    // ── String functions ────────────────────────────────────
+    case "contains": {
+      if (args.length !== 2) throw new RuntimeError(`contains() expects 2 arguments, got ${args.length}`);
+      const strFn = compileExpression(args[0], grouped);
+      const searchFn = compileExpression(args[1], grouped);
+      return (row) => String(strFn(row)).includes(String(searchFn(row)));
+    }
+    case "startsWith": {
+      if (args.length !== 2) throw new RuntimeError(`startsWith() expects 2 arguments, got ${args.length}`);
+      const strFn = compileExpression(args[0], grouped);
+      const prefixFn = compileExpression(args[1], grouped);
+      return (row) => String(strFn(row)).startsWith(String(prefixFn(row)));
+    }
+    case "endsWith": {
+      if (args.length !== 2) throw new RuntimeError(`endsWith() expects 2 arguments, got ${args.length}`);
+      const strFn = compileExpression(args[0], grouped);
+      const suffixFn = compileExpression(args[1], grouped);
+      return (row) => String(strFn(row)).endsWith(String(suffixFn(row)));
+    }
+    case "trim": {
+      if (args.length !== 1) throw new RuntimeError(`trim() expects 1 argument, got ${args.length}`);
+      const fn = compileExpression(args[0], grouped);
+      return (row) => String(fn(row)).trim();
+    }
+    case "substring": {
+      if (args.length < 2 || args.length > 3) throw new RuntimeError(`substring() expects 2 or 3 arguments, got ${args.length}`);
+      const strFn = compileExpression(args[0], grouped);
+      const startFn = compileExpression(args[1], grouped);
+      const lenFn = args.length === 3 ? compileExpression(args[2], grouped) : void 0;
+      return (row) => {
+        const s = String(strFn(row));
+        const start = Number(startFn(row));
+        if (lenFn) {
+          return s.substring(start, start + Number(lenFn(row)));
+        }
+        return s.substring(start);
+      };
+    }
+    case "replace": {
+      if (args.length !== 3) throw new RuntimeError(`replace() expects 3 arguments, got ${args.length}`);
+      const strFn = compileExpression(args[0], grouped);
+      const searchFn = compileExpression(args[1], grouped);
+      const replaceFn = compileExpression(args[2], grouped);
+      return (row) => String(strFn(row)).replaceAll(String(searchFn(row)), String(replaceFn(row)));
+    }
+    // Non-grouped aggregates used as functions return NaN or undefined — they're
+    // only meaningful as pipeline-level AggregateOps or in grouped selects
+    default:
+      throw new RuntimeError(`Unknown function: ${name}`);
+  }
+}
+function compileGroupAggregate(name, args) {
+  const fieldFn = args.length > 0 ? compileExpression(args[0], false) : void 0;
+  const secondFn = args.length > 1 ? compileExpression(args[1], false) : void 0;
+  const extractValues = (row) => row._group.map((r) => Number(fieldFn(r)));
+  switch (name) {
+    // ── Core ───────────────────────────────────────────────
+    case "sum":
+      return (row) => {
+        const group = row._group;
+        return group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
+      };
+    case "avg":
+      return (row) => {
+        const group = row._group;
+        if (group.length === 0) return 0;
+        const total = group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
+        return total / group.length;
+      };
+    case "min":
+      return (row) => {
+        const group = row._group;
+        if (group.length === 0) return null;
+        return group.reduce((min, r) => {
+          const val = fieldFn(r);
+          return val < min ? val : min;
+        }, fieldFn(group[0]));
+      };
+    case "max":
+      return (row) => {
+        const group = row._group;
+        if (group.length === 0) return null;
+        return group.reduce((max, r) => {
+          const val = fieldFn(r);
+          return val > max ? val : max;
+        }, fieldFn(group[0]));
+      };
+    case "count":
+      return (row) => {
+        const group = row._group;
+        return group.length;
+      };
+    // ── Statistical ───────────────────────────────────────
+    case "median":
+      return (row) => computeMedian(extractValues(row));
+    case "stddev":
+      return (row) => computeStddev(extractValues(row));
+    case "var":
+      return (row) => computeVariance(extractValues(row));
+    case "percentile":
+      return (row) => computePercentile(extractValues(row), Number(secondFn(row)));
+    case "skew":
+      return (row) => computeSkew(extractValues(row));
+    case "kurt":
+      return (row) => computeKurt(extractValues(row));
+    // ── Finance ───────────────────────────────────────────
+    case "vwap":
+      return (row) => {
+        const group = row._group;
+        let sumPV = 0, sumV = 0;
+        for (const r of group) {
+          const p = Number(fieldFn(r));
+          const v = Number(secondFn(r));
+          sumPV += p * v;
+          sumV += v;
+        }
+        return sumV === 0 ? 0 : sumPV / sumV;
+      };
+    case "wavg":
+      return (row) => {
+        const group = row._group;
+        let sumWV = 0, sumW = 0;
+        for (const r of group) {
+          const val = Number(fieldFn(r));
+          const w = Number(secondFn(r));
+          sumWV += val * w;
+          sumW += w;
+        }
+        return sumW === 0 ? 0 : sumWV / sumW;
+      };
+    case "drawdown":
+      return (row) => computeDrawdown(extractValues(row));
+    // ── Ratios ────────────────────────────────────────────
+    case "pct":
+      return (row) => {
+        const group = row._group;
+        return group.reduce((acc, r) => acc + Number(fieldFn(r)), 0);
+      };
+    case "sharpe":
+      return (row) => {
+        const vals = extractValues(row);
+        if (vals.length === 0) return 0;
+        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+        const sd = computeStddev(vals);
+        return sd === 0 ? 0 : mean / sd;
+      };
+    case "calmar":
+      return (row) => {
+        const vals = extractValues(row);
+        if (vals.length === 0) return 0;
+        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+        const dd = Math.abs(computeDrawdown(vals));
+        return dd === 0 ? 0 : mean / dd;
+      };
+    case "sortino":
+      return (row) => {
+        const vals = extractValues(row);
+        if (vals.length === 0) return 0;
+        const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+        const dsd = computeDownsideDeviation(vals, 0);
+        return dsd === 0 ? 0 : mean / dsd;
+      };
+    case "info_ratio":
+      return (row) => {
+        const group = row._group;
+        const excess = group.map((r) => Number(fieldFn(r)) - Number(secondFn(r)));
+        if (excess.length === 0) return 0;
+        const mean = excess.reduce((a, b) => a + b, 0) / excess.length;
+        const sd = computeStddev(excess);
+        return sd === 0 ? 0 : mean / sd;
+      };
+    // ── Counting ──────────────────────────────────────────
+    case "distinct_count":
+      return (row) => {
+        const group = row._group;
+        return new Set(group.map((r) => fieldFn(r))).size;
+      };
+    case "sum_abs":
+      return (row) => {
+        const group = row._group;
+        return group.reduce((acc, r) => acc + Math.abs(Number(fieldFn(r))), 0);
+      };
+    case "abs_sum":
+      return (row) => {
+        const group = row._group;
+        return Math.abs(group.reduce((acc, r) => acc + Number(fieldFn(r)), 0));
+      };
+    // ── Range ─────────────────────────────────────────────
+    case "first_value":
+      return (row) => {
+        const group = row._group;
+        return group.length > 0 ? fieldFn(group[0]) : null;
+      };
+    case "last_value":
+      return (row) => {
+        const group = row._group;
+        return group.length > 0 ? fieldFn(group[group.length - 1]) : null;
+      };
+    default:
+      throw new RuntimeError(`Unknown aggregate function: ${name}`);
+  }
+}
+function resolveFieldName(expr) {
+  switch (expr.kind) {
+    case "AliasExpr":
+      return expr.alias;
+    case "FieldAccess":
+      return expr.path[expr.path.length - 1];
+    case "FunctionCall":
+      return expr.name;
+    default:
+      return "value";
+  }
+}
+function compileOperation(op, isGrouped) {
+  switch (op.kind) {
+    case "WhereOp": {
+      const condFn = compileExpression(op.condition);
+      return {
+        fn: (data) => data.filter((row) => condFn(row)),
+        producesGrouped: false
+      };
+    }
+    case "SelectOp":
+      return compileSelectOp(op, isGrouped);
+    case "SortOp": {
+      const criteria = op.criteria.map((c) => ({
+        fn: compileExpression(c.expression),
+        dir: c.direction === "desc" ? -1 : 1
+      }));
+      return {
+        fn: (data) => {
+          return [...data].sort((a, b) => {
+            for (const { fn, dir } of criteria) {
+              const cmp = compareValues(fn(a), fn(b));
+              if (cmp !== 0) return cmp * dir;
+            }
+            return 0;
+          });
+        },
+        producesGrouped: false
+      };
+    }
+    case "GroupByOp": {
+      const keyFns = op.keys.map((k) => {
+        const fn = compileExpression(k);
+        const name = k.kind === "FieldAccess" ? k.path[k.path.length - 1] : "key";
+        return { fn, name };
+      });
+      return {
+        fn: (data) => {
+          const groups = groupByFn(data, keyFns);
+          return groups.map((g) => ({ ...g.keys, _group: g.rows }));
+        },
+        producesGrouped: true
+      };
+    }
+    case "JoinOp": {
+      const rightSource = op.right;
+      if (op.condition.kind === "BinaryExpr" && op.condition.operator === "==" && op.condition.left.kind === "FieldAccess" && op.condition.right.kind === "FieldAccess") {
+        const leftKeyFn = compileExpression(op.condition.left);
+        const rightKeyFn = compileExpression(op.condition.right);
+        return {
+          fn: (data, context) => {
+            const rightData = context[rightSource];
+            if (!rightData) {
+              throw new RuntimeError(`Join source "${rightSource}" not found in context`);
+            }
+            return hashJoin(data, rightData, leftKeyFn, rightKeyFn);
+          },
+          producesGrouped: false
+        };
+      }
+      const condFn = compileExpression(op.condition);
+      return {
+        fn: (data, context) => {
+          const rightData = context[rightSource];
+          if (!rightData) {
+            throw new RuntimeError(`Join source "${rightSource}" not found in context`);
+          }
+          return nestedLoopJoin(data, rightData, condFn);
+        },
+        producesGrouped: false
+      };
+    }
+    case "FirstOp": {
+      const count = op.count;
+      return {
+        fn: (data) => data.slice(0, count),
+        producesGrouped: false
+      };
+    }
+    case "LastOp": {
+      const count = op.count;
+      return {
+        fn: (data) => data.slice(-count),
+        producesGrouped: false
+      };
+    }
+    case "DistinctOp": {
+      const keyFn = op.fields ? (() => {
+        const fns = op.fields.map((f) => compileExpression(f));
+        return (row) => JSON.stringify(fns.map((fn) => fn(row)));
+      })() : void 0;
+      return {
+        fn: (data) => distinctFn(data, keyFn),
+        producesGrouped: false
+      };
+    }
+    case "FlattenOp": {
+      if (op.field) {
+        const fieldFn = compileExpression(op.field);
+        return {
+          fn: (data) => data.flatMap((row) => {
+            const val = fieldFn(row);
+            return Array.isArray(val) ? val : [val];
+          }),
+          producesGrouped: false
+        };
+      }
+      return {
+        fn: (data) => data.flat(),
+        producesGrouped: false
+      };
+    }
+    case "TransposeOp": {
+      const headerFn = op.headerField ? compileExpression(op.headerField) : void 0;
+      const headerFieldName = op.headerField ? resolveFieldName(op.headerField) : void 0;
+      return {
+        fn: (data) => transposeFn(data, headerFn, headerFieldName),
+        producesGrouped: false
+      };
+    }
+    case "RollupOp": {
+      const keyFns = op.keys.map((k) => {
+        const fn = compileExpression(k);
+        const name = resolveFieldName(k);
+        return { fn, name };
+      });
+      const aggFns = op.aggregates.map((a) => {
+        const fn = compileExpression(a, true);
+        const name = resolveFieldName(a);
+        return { fn, name };
+      });
+      const pctCols = /* @__PURE__ */ new Set();
+      for (const a of op.aggregates) {
+        const expr = a.kind === "AliasExpr" ? a.expression : a;
+        if (expr.kind === "FunctionCall" && expr.name === "pct") {
+          pctCols.add(resolveFieldName(a));
+        }
+      }
+      return {
+        fn: (data) => {
+          const results = rollupFn(data, keyFns, aggFns);
+          if (pctCols.size > 0) {
+            const numKeys = keyFns.length;
+            const grandRow = results.find((r) => r._rollupLevel === numKeys);
+            for (const col of pctCols) {
+              const total = Number(grandRow?.[col]) || 1;
+              for (const row of results) {
+                row[col] = Number(row[col]) / total * 100;
+              }
+            }
+            if (pctCols.size === aggFns.length) {
+              return results.filter((r) => r._rollupLevel !== numKeys);
+            }
+          }
+          return results;
+        },
+        producesGrouped: false
+      };
+    }
+    case "PivotOp": {
+      const pivotFn = compileExpression(op.pivotField);
+      const aggCompilers = op.aggregates.map((a) => ({
+        fn: compileExpression(a, true),
+        // grouped = true
+        name: resolveFieldName(a)
+      }));
+      const singleAggregate = aggCompilers.length === 1;
+      return {
+        fn: (data) => {
+          if (isGrouped) {
+            return pivotGroupedFn(data, pivotFn, aggCompilers, singleAggregate);
+          }
+          return pivotFlatFn(data, pivotFn, aggCompilers, singleAggregate);
+        },
+        producesGrouped: false
+      };
+    }
+    case "MapOp": {
+      const fieldCompilers = op.fields.map((field) => {
+        const name = resolveFieldName(field);
+        const fn = compileExpression(field, isGrouped);
+        return { name, fn };
+      });
+      return {
+        fn: (data) => data.map((row) => {
+          const result = { ...row };
+          for (const { name, fn } of fieldCompilers) {
+            result[name] = fn(row);
+          }
+          return result;
+        }),
+        producesGrouped: isGrouped
+      };
+    }
+    case "ReduceOp": {
+      const initialFn = compileExpression(op.initial);
+      const accFn = compileExpression(op.accumulator);
+      return {
+        fn: (data) => {
+          let acc = initialFn({});
+          for (const row of data) {
+            acc = accFn({ ...row, _acc: acc });
+          }
+          return acc;
+        },
+        producesGrouped: false
+      };
+    }
+    case "AggregateOp": {
+      const argFns = op.args?.map((a) => compileExpression(a));
+      const primaryFn = argFns ? argFns[0] : op.field ? compileExpression(op.field) : void 0;
+      const secondFn = argFns ? argFns[1] : void 0;
+      const aggName = op.function;
+      return {
+        fn: (data) => {
+          const vals = () => data.map((row) => Number(primaryFn(row)));
+          switch (aggName) {
+            // ── Core ──────────────────────────────────────
+            case "count":
+              return data.length;
+            case "sum":
+              return data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
+            case "avg": {
+              if (data.length === 0) return 0;
+              const total = data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
+              return total / data.length;
+            }
+            case "min":
+              return data.reduce((min, row) => {
+                const val = primaryFn(row);
+                return val < min ? val : min;
+              }, primaryFn(data[0]));
+            case "max":
+              return data.reduce((max, row) => {
+                const val = primaryFn(row);
+                return val > max ? val : max;
+              }, primaryFn(data[0]));
+            // ── Statistical ───────────────────────────────
+            case "median":
+              return computeMedian(vals());
+            case "stddev":
+              return computeStddev(vals());
+            case "var":
+              return computeVariance(vals());
+            case "percentile":
+              return computePercentile(vals(), Number(secondFn(data[0])));
+            case "skew":
+              return computeSkew(vals());
+            case "kurt":
+              return computeKurt(vals());
+            // ── Finance ───────────────────────────────────
+            case "vwap": {
+              let sumPV = 0, sumV = 0;
+              for (const row of data) {
+                const p = Number(primaryFn(row));
+                const v = Number(secondFn(row));
+                sumPV += p * v;
+                sumV += v;
+              }
+              return sumV === 0 ? 0 : sumPV / sumV;
+            }
+            case "wavg": {
+              let sumWV = 0, sumW = 0;
+              for (const row of data) {
+                const val = Number(primaryFn(row));
+                const w = Number(secondFn(row));
+                sumWV += val * w;
+                sumW += w;
+              }
+              return sumW === 0 ? 0 : sumWV / sumW;
+            }
+            case "drawdown":
+              return computeDrawdown(vals());
+            // ── Ratios ────────────────────────────────────
+            case "pct": {
+              return data.reduce((acc, row) => acc + Number(primaryFn(row)), 0);
+            }
+            case "sharpe": {
+              const v = vals();
+              if (v.length === 0) return 0;
+              const mean = v.reduce((a, b) => a + b, 0) / v.length;
+              const sd = computeStddev(v);
+              return sd === 0 ? 0 : mean / sd;
+            }
+            case "calmar": {
+              const v = vals();
+              if (v.length === 0) return 0;
+              const mean = v.reduce((a, b) => a + b, 0) / v.length;
+              const dd = Math.abs(computeDrawdown(v));
+              return dd === 0 ? 0 : mean / dd;
+            }
+            case "sortino": {
+              const v = vals();
+              if (v.length === 0) return 0;
+              const mean = v.reduce((a, b) => a + b, 0) / v.length;
+              const dsd = computeDownsideDeviation(v, 0);
+              return dsd === 0 ? 0 : mean / dsd;
+            }
+            case "info_ratio": {
+              const excess = data.map((row) => Number(primaryFn(row)) - Number(secondFn(row)));
+              if (excess.length === 0) return 0;
+              const mean = excess.reduce((a, b) => a + b, 0) / excess.length;
+              const sd = computeStddev(excess);
+              return sd === 0 ? 0 : mean / sd;
+            }
+            // ── Counting ──────────────────────────────────
+            case "distinct_count":
+              return new Set(data.map((row) => primaryFn(row))).size;
+            case "sum_abs":
+              return data.reduce((acc, row) => acc + Math.abs(Number(primaryFn(row))), 0);
+            case "abs_sum":
+              return Math.abs(data.reduce((acc, row) => acc + Number(primaryFn(row)), 0));
+            // ── Range ─────────────────────────────────────
+            case "first_value":
+              return data.length > 0 ? primaryFn(data[0]) : null;
+            case "last_value":
+              return data.length > 0 ? primaryFn(data[data.length - 1]) : null;
+          }
+        },
+        producesGrouped: false
+      };
+    }
+  }
+}
+function compileSelectOp(op, isGrouped) {
+  const fieldCompilers = op.fields.map((field) => {
+    const name = resolveFieldName(field);
+    const fn = compileExpression(field, isGrouped);
+    return { name, fn };
+  });
+  const windowDefs = [];
+  for (const { fn } of fieldCompilers) {
+    const wDef = fn._windowDef;
+    if (wDef) windowDefs.push(wDef);
+  }
+  if (windowDefs.length > 0) {
+    return {
+      fn: (data) => {
+        const windowValues = computeWindowValues(data, windowDefs);
+        return data.map((row, i) => {
+          const enrichedRow = { ...row, _windowCtx: windowValues[i] };
+          const result = {};
+          for (const { name, fn } of fieldCompilers) {
+            result[name] = fn(enrichedRow);
+          }
+          return result;
+        });
+      },
+      producesGrouped: false
+    };
+  }
+  return {
+    fn: (data) => {
+      return data.map((row) => {
+        const result = {};
+        for (const { name, fn } of fieldCompilers) {
+          result[name] = fn(row);
+        }
+        return result;
+      });
+    },
+    producesGrouped: false
+  };
+}
+function compile(ast, source2) {
+  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: source2, 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);
+}
+
+// src/server/routes/control.ts
+function registerControlRoutes(app, sourceManager, endpointRegistry, configCallbacks) {
+  app.get("/api/_control/sources", async () => {
+    return sourceManager.getAllStatuses();
+  });
+  app.post("/api/_control/sources", async (req) => {
+    const { name, config } = req.body;
+    await sourceManager.addSource(name, config);
+    await configCallbacks.onSourceChange(name, config);
+    return { ok: true, name, status: sourceManager.getSourceStatus(name) };
+  });
+  app.delete("/api/_control/sources/:name", async (req) => {
+    const { name } = req.params;
+    const removed = sourceManager.removeSource(name);
+    if (!removed) return { ok: false, error: `Source "${name}" not found` };
+    await configCallbacks.onSourceChange(name, null);
+    return { ok: true, name };
+  });
+  app.post("/api/_control/sources/:name/test", async (req) => {
+    const { name } = req.params;
+    const data = sourceManager.getSourceData(name);
+    if (!data) return { ok: false, error: `Source "${name}" not found` };
+    return {
+      ok: true,
+      rowCount: data.length,
+      sample: data.slice(0, 3),
+      status: sourceManager.getSourceStatus(name)
+    };
+  });
+  app.get("/api/_control/endpoints", async () => {
+    const result = {};
+    for (const [path, config] of endpointRegistry.endpoints) {
+      result[path] = config;
+    }
+    return result;
+  });
+  app.post("/api/_control/endpoints", async (req) => {
+    const { path, config } = req.body;
+    endpointRegistry.endpoints.set(path, config);
+    endpointRegistry.onAdd?.(path, config);
+    await configCallbacks.onEndpointChange(path, config);
+    return { ok: true, path };
+  });
+  app.delete("/api/_control/endpoints", async (req) => {
+    const path = req.body.path;
+    const removed = endpointRegistry.endpoints.delete(path);
+    if (!removed) return { ok: false, error: `Endpoint "${path}" not found` };
+    endpointRegistry.onRemove?.(path);
+    await configCallbacks.onEndpointChange(path, null);
+    return { ok: true, path };
+  });
+  app.post("/api/_control/refresh", async () => {
+    await sourceManager.refreshAll();
+    return { ok: true };
+  });
+  app.post("/api/_control/query", async (req) => {
+    const { query: expr } = req.body;
+    const context = sourceManager.getContext();
+    try {
+      const result = query(context, expr);
+      return { ok: true, result };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+}
+
+// src/server/cache.ts
+var ResponseCache = class {
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  set(key, data, ttlMs) {
+    this.entries.set(key, { data, expiresAt: Date.now() + ttlMs });
+  }
+  invalidate(key) {
+    this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+
+// src/server/routes/dynamic.ts
+function registerDynamicRoutes(app, sourceManager, endpoints) {
+  const cache = new ResponseCache();
+  app.addHook("onRequest", async (req, reply) => {
+    const path = req.url.split("?")[0];
+    if (!path.startsWith("/api/") || path.startsWith("/api/_control")) return;
+    const config = endpoints.get(path);
+    if (!config) return;
+    if (config.cache) {
+      const cached = cache.get(path);
+      if (cached !== void 0) {
+        reply.send(cached);
+        return;
+      }
+    }
+    const context = sourceManager.getContext();
+    try {
+      const result = query(context, config.query);
+      if (config.cache) {
+        cache.set(path, result, parseDuration(config.cache));
+      }
+      reply.send(result);
+    } catch (err) {
+      reply.status(500).send({
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+}
+
+// src/server/routes/sse.ts
+function registerSSERoutes(app, sourceManager) {
+  app.get("/api/_control/sse", async (req, reply) => {
+    const queriesParam = req.query.queries;
+    if (!queriesParam) {
+      return reply.status(400).send({ error: "queries parameter required (JSON array of strings)" });
+    }
+    let queries;
+    try {
+      queries = JSON.parse(queriesParam);
+      if (!Array.isArray(queries)) throw new Error();
+    } catch {
+      return reply.status(400).send({ error: "queries must be a JSON array of strings" });
+    }
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    sendAllPanels(reply.raw, queries, sourceManager);
+    let pending = false;
+    let timer = null;
+    const throttledSend = () => {
+      if (timer) {
+        pending = true;
+        return;
+      }
+      sendAllPanels(reply.raw, queries, sourceManager);
+      timer = setTimeout(() => {
+        timer = null;
+        if (pending) {
+          pending = false;
+          throttledSend();
+        }
+      }, 1e3);
+    };
+    const unsubscribe = sourceManager.onSourceUpdate(throttledSend);
+    const heartbeat = setInterval(() => {
+      reply.raw.write(":heartbeat\n\n");
+    }, 15e3);
+    req.raw.on("close", () => {
+      unsubscribe();
+      clearInterval(heartbeat);
+      if (timer) clearTimeout(timer);
+    });
+    await reply.hijack();
+  });
+}
+function sendAllPanels(res, queries, sourceManager) {
+  const context = sourceManager.getContext();
+  for (let i = 0; i < queries.length; i++) {
+    try {
+      const result = query(context, queries[i]);
+      const event = JSON.stringify({ panelIndex: i, result });
+      res.write(`data: ${event}
+
+`);
+    } catch (err) {
+      const event = JSON.stringify({ panelIndex: i, error: err instanceof Error ? err.message : String(err) });
+      res.write(`data: ${event}
+
+`);
+    }
+  }
+}
+
+// src/server/activity-log.ts
+var MAX_ENTRIES = 100;
+var entries = [];
+function logActivity(level, message) {
+  entries.push({
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message
+  });
+  if (entries.length > MAX_ENTRIES) {
+    entries.splice(0, entries.length - MAX_ENTRIES);
+  }
+}
+function getActivityLog(since) {
+  if (!since) return [...entries];
+  return entries.filter((e) => e.time > since);
+}
+function info(msg) {
+  logActivity("info", msg);
+}
+function warn(msg) {
+  logActivity("warn", msg);
+}
+function error(msg) {
+  logActivity("error", msg);
+}
+
+// src/server/app.ts
+async function createServer(config, configPath, cwd) {
+  const app = Fastify({ logger: false });
+  await app.register(cors);
+  const sourceManager = new SourceManager(cwd);
+  const startedAt = /* @__PURE__ */ new Date();
+  info("Server starting...");
+  for (const [name, sourceConfig] of Object.entries(config.sources)) {
+    try {
+      await sourceManager.addSource(name, sourceConfig);
+      info(`Source "${name}" loaded (${sourceConfig.type})`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(`Source "${name}" failed: ${msg}`);
+      console.error(`Failed to start source "${name}":`, msg);
+    }
+  }
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const [path, endpointConfig] of Object.entries(config.endpoints)) {
+    endpoints.set(path, endpointConfig);
+    info(`Endpoint registered: ${path}`);
+  }
+  const configCallbacks = {
+    onSourceChange: async (name, sourceConfig) => {
+      if (sourceConfig) {
+        config.sources[name] = sourceConfig;
+        info(`Source "${name}" added (${sourceConfig.type})`);
+      } else {
+        delete config.sources[name];
+        warn(`Source "${name}" removed`);
+      }
+      await saveConfig(config, configPath);
+    },
+    onEndpointChange: async (path, endpointConfig) => {
+      if (endpointConfig) {
+        config.endpoints[path] = endpointConfig;
+        info(`Endpoint "${path}" added`);
+      } else {
+        delete config.endpoints[path];
+        warn(`Endpoint "${path}" removed`);
+      }
+      await saveConfig(config, configPath);
+    }
+  };
+  app.addHook("onResponse", async (request, reply) => {
+    const url = request.url;
+    if (url === "/health" || url === "/status" || url === "/api/_control/activity") return;
+    if (url === "/api/_control/sources" && request.method === "GET") return;
+    if (url === "/api/_control/endpoints" && request.method === "GET") return;
+    const status = reply.statusCode;
+    const level = status >= 400 ? "error" : "info";
+    logActivity(level, `${request.method} ${url} \u2192 ${status}`);
+  });
+  app.get("/api/_control/activity", async (req) => {
+    return getActivityLog(req.query.since);
+  });
+  registerHealthRoutes(app, sourceManager, startedAt);
+  registerControlRoutes(app, sourceManager, { endpoints }, configCallbacks);
+  registerSSERoutes(app, sourceManager);
+  registerDynamicRoutes(app, sourceManager, endpoints);
+  info("Server ready");
+  return { app, sourceManager, endpoints };
+}
+
+// src/utils/banner.ts
+import chalk3 from "chalk";
+var LOGO = [
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557   \u2588\u2588\u2557",
+  "  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D",
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u255A\u2588\u2588\u2588\u2588\u2554\u255D ",
+  "  \u2588\u2588\u2554\u2550\u2550\u2550\u255D  \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2551\u2584\u2584 \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557   \u255A\u2588\u2588\u2554\u255D  ",
+  "  \u2588\u2588\u2551      \u2588\u2588\u2551 \u2588\u2588\u2551      \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551  \u2588\u2588\u2551    \u2588\u2588\u2551   ",
+  "  \u255A\u2550\u255D      \u255A\u2550\u255D \u255A\u2550\u255D      \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2580\u2580\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D    \u255A\u2550\u255D   "
+];
+var GRADIENT_COLORS = [
+  "#06b6d4",
+  // cyan
+  "#0891b2",
+  "#0e7490",
+  "#2563eb",
+  // blue
+  "#4f46e5",
+  "#7c3aed"
+  // violet
+];
+function applyGradient(line, colorIndex) {
+  const color = GRADIENT_COLORS[colorIndex % GRADIENT_COLORS.length];
+  return chalk3.hex(color)(line);
+}
+function printBanner() {
+  console.log();
+  LOGO.forEach((line, i) => {
+    console.log(applyGradient(line, i));
+  });
+  console.log();
+  console.log(chalk3.dim(`  v0.1.0 \u2014 data sources, aggregations, APIs, and terminal dashboards`));
+  console.log();
+}
+function printCompactBanner() {
+  console.log();
+  console.log(
+    chalk3.hex("#06b6d4").bold("  \u2554\u2550\u2557 \u2566 \u2554\u2550\u2557 \u2554\u2550\u2557 \u2554\u2550\u2557 \u2566 \u2566 \u2554\u2550\u2557 \u2566\u2550\u2557 \u2566 \u2566")
+  );
+  console.log(
+    chalk3.hex("#4f46e5").bold("  \u2560\u2550\u255D \u2551 \u2560\u2550\u255D \u2551\u2563  \u2551\u2550\u256C\u2557\u2551 \u2551 \u2551\u2563  \u2560\u2566\u255D \u255A\u2566\u255D")
+  );
+  console.log(
+    chalk3.hex("#7c3aed").bold("  \u2569   \u2569 \u2569   \u255A\u2550\u255D \u255A\u2550\u255D\u255A\u255A\u2550\u255D \u255A\u2550\u255D \u2569\u255A\u2550  \u2569 ")
+  );
+  console.log();
+}
+function printServerStartup(opts) {
+  const { url, sourceCount, endpointCount } = opts;
+  console.log(chalk3.hex("#06b6d4").bold("  \u25CF Server running"));
+  console.log();
+  console.log(`  ${chalk3.dim("URL")}        ${chalk3.white.bold(url)}`);
+  console.log(`  ${chalk3.dim("Sources")}    ${chalk3.white(String(sourceCount))} loaded`);
+  console.log(`  ${chalk3.dim("Endpoints")}  ${chalk3.white(String(endpointCount))} registered`);
+  console.log();
+  console.log(chalk3.dim("  Press Ctrl+C to stop"));
+  console.log();
+}
+
+// src/commands/serve.ts
+async function serveCommand(opts) {
+  const cwd = process.cwd();
+  const pqDir = resolve4(cwd, ".pipequery");
+  const serverJsonPath = resolve4(pqDir, "server.json");
+  if (opts.stop) {
+    return stopDaemon(serverJsonPath);
+  }
+  const { config, path: configPath } = await loadConfig(cwd);
+  const port = opts.port ?? config.server.port;
+  const host = opts.host ?? config.server.host;
+  if (opts.daemon) {
+    return startDaemon(cwd, port, host);
+  }
+  const { app, sourceManager } = await createServer(config, configPath, cwd);
+  await mkdir(pqDir, { recursive: true });
+  const logPath = resolve4(pqDir, "server.log");
+  await writeFile3(serverJsonPath, JSON.stringify({ url: `http://localhost:${port}`, pid: process.pid, daemon: false, log: logPath }));
+  await app.listen({ port, host });
+  const sourceCount = sourceManager.getSourceNames().length;
+  const endpointCount = Object.keys(config.endpoints).length;
+  const url = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
+  printCompactBanner();
+  printServerStartup({ url, sourceCount, endpointCount });
+  const shutdown = async () => {
+    log.dim("\nShutting down...");
+    await sourceManager.dispose();
+    await app.close();
+    try {
+      await unlink(serverJsonPath);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function startDaemon(cwd, port, host) {
+  const pqDir = resolve4(cwd, ".pipequery");
+  const serverJsonPath = resolve4(pqDir, "server.json");
+  const logPath = resolve4(pqDir, "server.log");
+  if (existsSync3(serverJsonPath)) {
+    try {
+      const info2 = JSON.parse(await readFile3(serverJsonPath, "utf-8"));
+      const res = await fetch(`${info2.url}/health`).catch(() => null);
+      if (res?.ok) {
+        log.warn(`Server already running at ${info2.url} (PID: ${info2.pid})`);
+        return;
+      }
+    } catch {
+    }
+  }
+  await mkdir(pqDir, { recursive: true });
+  const scriptPath = process.argv[1];
+  const args = ["serve", "--port", String(port), "--host", host];
+  const out = await import("fs").then((fs) => fs.openSync(logPath, "a"));
+  const child = spawn(process.execPath, [scriptPath, ...args], {
+    cwd,
+    detached: true,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, PQ_DAEMON: "1" }
+  });
+  child.unref();
+  await writeFile3(serverJsonPath, JSON.stringify({
+    url: `http://localhost:${port}`,
+    pid: child.pid,
+    daemon: true,
+    log: logPath
+  }));
+  log.success(`PipeQuery server started in background (PID: ${child.pid})`);
+  log.dim(`Logs: ${logPath}`);
+  log.dim(`Stop with: pq serve --stop`);
+}
+async function stopDaemon(serverJsonPath) {
+  if (!existsSync3(serverJsonPath)) {
+    log.error("No running server found.");
+    return;
+  }
+  try {
+    const info2 = JSON.parse(await readFile3(serverJsonPath, "utf-8"));
+    process.kill(info2.pid, "SIGTERM");
+    await unlink(serverJsonPath);
+    log.success(`Server stopped (PID: ${info2.pid})`);
+  } catch (err) {
+    log.error(`Failed to stop server: ${err instanceof Error ? err.message : err}`);
+    try {
+      await unlink(serverJsonPath);
+    } catch {
+    }
+  }
+}
+
+// src/commands/query.ts
+import chalk4 from "chalk";
+
+// src/utils/server-discovery.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+async function getServerUrl() {
+  const cwd = process.cwd();
+  const serverJsonPath = resolve5(cwd, ".pipequery", "server.json");
+  if (existsSync4(serverJsonPath)) {
+    try {
+      const info2 = JSON.parse(await readFile4(serverJsonPath, "utf-8"));
+      const res = await fetch(`${info2.url}/health`).catch(() => null);
+      if (res?.ok) return info2.url;
+    } catch {
+    }
+  }
+  const configPath = findConfigPath(cwd);
+  if (configPath) {
+    try {
+      const config = await readYaml(configPath);
+      if (config.remote?.url) {
+        const res = await fetch(`${config.remote.url}/health`).catch(() => null);
+        if (res?.ok) return config.remote.url;
+      }
+    } catch {
+    }
+  }
+  throw new Error("No running PipeQuery server found. Start one with: pq serve");
+}
+
+// src/commands/query.ts
+async function queryCommand(expression, opts) {
+  const serverUrl = await getServerUrl();
+  const res = await fetch(`${serverUrl}/api/_control/query`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: expression })
+  });
+  const json = await res.json();
+  if (!json.ok) {
+    log.error(json.error ?? "Query failed");
+    process.exit(1);
+  }
+  const result = json.result;
+  if (opts.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (Array.isArray(result) && result.length > 0 && typeof result[0] === "object") {
+    renderTable(result);
+  } else if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+    renderTable([result]);
+  } else {
+    console.log(result);
+  }
+}
+function renderTable(rows) {
+  if (rows.length === 0) {
+    log.dim("(empty result)");
+    return;
+  }
+  const columns = Object.keys(rows[0]);
+  const widths = columns.map((col) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, formatCell(row[col]).length), 0);
+    return Math.max(col.length, maxData);
+  });
+  const header = columns.map((col, i) => chalk4.hex("#06b6d4").bold(col.padEnd(widths[i]))).join("  ");
+  const separator = widths.map((w) => chalk4.dim("\u2500".repeat(w))).join(chalk4.dim("\u2500\u2500"));
+  console.log();
+  console.log(`  ${header}`);
+  console.log(`  ${separator}`);
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const val = formatCell(row[col]);
+      return typeof row[col] === "number" ? chalk4.hex("#f59e0b")(val.padStart(widths[i])) : val.padEnd(widths[i]);
+    }).join("  ");
+    console.log(`  ${line}`);
+  }
+  console.log();
+  console.log(chalk4.dim(`  ${rows.length} row(s)`));
+  console.log();
+}
+function formatCell(value) {
+  if (value == null) return "";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? String(value) : value.toFixed(2);
+  }
+  return String(value);
+}
+
+// src/commands/source.ts
+import chalk5 from "chalk";
+async function sourceListCommand() {
+  const cwd = process.cwd();
+  try {
+    const serverUrl = await getServerUrl();
+    const res = await fetch(`${serverUrl}/api/_control/sources`);
+    const statuses = await res.json();
+    if (Object.keys(statuses).length === 0) {
+      log.dim("No sources configured. Add one with: pq source add <name>");
+      return;
+    }
+    console.log(chalk5.bold("Sources:\n"));
+    for (const [name, status] of Object.entries(statuses)) {
+      const icon = status.healthy ? chalk5.green("\u25CF") : chalk5.red("\u25CF");
+      const rows = chalk5.dim(`${status.rowCount} rows`);
+      const err = status.error ? chalk5.red(` (${status.error})`) : "";
+      console.log(`  ${icon} ${chalk5.bold(name)}  ${rows}${err}`);
+    }
+  } catch {
+    const { config } = await loadConfig(cwd);
+    const sources = Object.entries(config.sources);
+    if (sources.length === 0) {
+      log.dim("No sources configured. Add one with: pq source add <name>");
+      return;
+    }
+    console.log(chalk5.bold("Sources (server not running):\n"));
+    for (const [name, src] of sources) {
+      const type = chalk5.cyan(src.type);
+      const detail = "url" in src ? chalk5.dim(src.url) : "path" in src ? chalk5.dim(src.path) : "";
+      console.log(`  \u25CB ${chalk5.bold(name)}  ${type}  ${detail}`);
+    }
+  }
+}
+async function sourceAddCommand(name, opts) {
+  const cwd = process.cwd();
+  const { config, path: configPath } = await loadConfig(cwd);
+  let sourceConfig;
+  switch (opts.type) {
+    case "rest":
+      if (!opts.url) throw new Error("--url is required for REST sources");
+      sourceConfig = {
+        type: "rest",
+        url: opts.url,
+        interval: opts.interval ?? "30s",
+        ...opts.dataPath ? { dataPath: opts.dataPath } : {}
+      };
+      break;
+    case "websocket":
+      if (!opts.url) throw new Error("--url is required for WebSocket sources");
+      sourceConfig = { type: "websocket", url: opts.url };
+      break;
+    case "file":
+      if (!opts.path) throw new Error("--path is required for file sources");
+      sourceConfig = {
+        type: "file",
+        path: opts.path,
+        ...opts.watch ? { watch: true } : {}
+      };
+      break;
+    default:
+      throw new Error(`Unknown source type: ${opts.type}. Use: rest, websocket, file`);
+  }
+  config.sources[name] = sourceConfig;
+  await saveConfig(config, configPath);
+  try {
+    const serverUrl = await getServerUrl();
+    const res = await fetch(`${serverUrl}/api/_control/sources`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name, config: sourceConfig })
+    });
+    const json = await res.json();
+    if (json.ok) {
+      log.success(`Source "${name}" added and live (${json.status?.rowCount ?? 0} rows)`);
+      return;
+    }
+  } catch {
+  }
+  log.success(`Source "${name}" added to config. Start server with: pq serve`);
+}
+async function sourceRemoveCommand(name) {
+  const cwd = process.cwd();
+  const { config, path: configPath } = await loadConfig(cwd);
+  if (!config.sources[name]) {
+    log.error(`Source "${name}" not found`);
+    return;
+  }
+  delete config.sources[name];
+  await saveConfig(config, configPath);
+  try {
+    const serverUrl = await getServerUrl();
+    await fetch(`${serverUrl}/api/_control/sources/${encodeURIComponent(name)}`, { method: "DELETE" });
+    log.success(`Source "${name}" removed (live)`);
+    return;
+  } catch {
+  }
+  log.success(`Source "${name}" removed from config`);
+}
+async function sourceTestCommand(name) {
+  const serverUrl = await getServerUrl();
+  const res = await fetch(`${serverUrl}/api/_control/sources/${encodeURIComponent(name)}/test`, { method: "POST" });
+  const json = await res.json();
+  if (!json.ok) {
+    log.error(json.error ?? "Test failed");
+    return;
+  }
+  log.success(`Source "${name}": ${json.rowCount} rows`);
+  if (json.sample && json.sample.length > 0) {
+    console.log(chalk5.dim("\nSample:"));
+    console.log(JSON.stringify(json.sample, null, 2));
+  }
+}
+
+// src/commands/endpoint.ts
+import chalk6 from "chalk";
+async function endpointListCommand() {
+  const cwd = process.cwd();
+  try {
+    const serverUrl = await getServerUrl();
+    const res = await fetch(`${serverUrl}/api/_control/endpoints`);
+    const endpoints = await res.json();
+    if (Object.keys(endpoints).length === 0) {
+      log.dim('No endpoints configured. Add one with: pq endpoint add <path> --query "<expr>"');
+      return;
+    }
+    console.log(chalk6.bold("Endpoints:\n"));
+    for (const [path, config] of Object.entries(endpoints)) {
+      const cache = config.cache ? chalk6.dim(`(cache: ${config.cache})`) : "";
+      console.log(`  ${chalk6.green("GET")} ${chalk6.bold(path)}  ${cache}`);
+      console.log(`      ${chalk6.dim(config.query)}`);
+    }
+  } catch {
+    const { config } = await loadConfig(cwd);
+    const entries2 = Object.entries(config.endpoints);
+    if (entries2.length === 0) {
+      log.dim('No endpoints configured. Add one with: pq endpoint add <path> --query "<expr>"');
+      return;
+    }
+    console.log(chalk6.bold("Endpoints (server not running):\n"));
+    for (const [path, cfg] of entries2) {
+      console.log(`  ${chalk6.green("GET")} ${chalk6.bold(path)}`);
+      console.log(`      ${chalk6.dim(cfg.query)}`);
+    }
+  }
+}
+async function endpointAddCommand(path, opts) {
+  const cwd = process.cwd();
+  const { config, path: configPath } = await loadConfig(cwd);
+  const apiPath = path.startsWith("/") ? path : `/${path}`;
+  const endpointConfig = {
+    query: opts.query,
+    ...opts.cache ? { cache: opts.cache } : {}
+  };
+  config.endpoints[apiPath] = endpointConfig;
+  await saveConfig(config, configPath);
+  try {
+    const serverUrl = await getServerUrl();
+    await fetch(`${serverUrl}/api/_control/endpoints`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: apiPath, config: endpointConfig })
+    });
+    log.success(`Endpoint ${apiPath} registered (live)`);
+    return;
+  } catch {
+  }
+  log.success(`Endpoint ${apiPath} added to config. Start server with: pq serve`);
+}
+async function endpointRemoveCommand(path) {
+  const cwd = process.cwd();
+  const { config, path: configPath } = await loadConfig(cwd);
+  const apiPath = path.startsWith("/") ? path : `/${path}`;
+  if (!config.endpoints[apiPath]) {
+    log.error(`Endpoint "${apiPath}" not found`);
+    return;
+  }
+  delete config.endpoints[apiPath];
+  await saveConfig(config, configPath);
+  try {
+    const serverUrl = await getServerUrl();
+    await fetch(`${serverUrl}/api/_control/endpoints/${apiPath.slice(1)}`, { method: "DELETE" });
+    log.success(`Endpoint ${apiPath} removed (live)`);
+    return;
+  } catch {
+  }
+  log.success(`Endpoint ${apiPath} removed from config`);
+}
+
+// src/commands/dashboard.ts
+import React4 from "react";
+import { render } from "ink";
+
+// src/tui/App.tsx
+import React3, { useState as useState4, useMemo, useCallback as useCallback2 } from "react";
+import { Box as Box11, Text as Text10, useStdout } from "ink";
+
+// src/tui/hooks/useLiveData.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+import http from "http";
+function useLiveData(serverUrl, queries, fallbackMs) {
+  const [results, setResults] = useState(/* @__PURE__ */ new Map());
+  const [loading, setLoading] = useState(true);
+  const [connected, setConnected] = useState(false);
+  const abortRef = useRef(null);
+  const fallbackTimerRef = useRef(null);
+  const queriesKey = queries.join("|||");
+  useEffect(() => {
+    if (queries.length === 0) return;
+    const abort = new AbortController();
+    abortRef.current = abort;
+    let sseConnected = false;
+    const connectSSE = () => {
+      if (abort.signal.aborted) return;
+      const url = new URL("/api/_control/sse", serverUrl);
+      url.searchParams.set("queries", JSON.stringify(queries));
+      const req = http.get(url.toString(), { signal: abort.signal }, (res) => {
+        if (res.statusCode !== 200) {
+          startPolling();
+          return;
+        }
+        sseConnected = true;
+        setConnected(true);
+        stopPolling();
+        let buffer = "";
+        res.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const blocks = buffer.split("\n\n");
+          buffer = blocks.pop() ?? "";
+          const updates = [];
+          for (const block of blocks) {
+            const dataLine = block.split("\n").find((l) => l.startsWith("data: "));
+            if (!dataLine) continue;
+            try {
+              const event = JSON.parse(dataLine.slice(6));
+              updates.push({ index: event.panelIndex, result: event.result, error: event.error });
+            } catch {
+            }
+          }
+          if (updates.length > 0) {
+            setResults((prev) => {
+              const next = new Map(prev);
+              for (const u of updates) {
+                const query2 = queries[u.index];
+                if (query2) {
+                  next.set(query2, u.error ? { data: null, error: u.error } : { data: u.result });
+                }
+              }
+              return next;
+            });
+            setLoading(false);
+          }
+        });
+        res.on("end", () => {
+          sseConnected = false;
+          setConnected(false);
+          if (!abort.signal.aborted) {
+            startPolling();
+            setTimeout(connectSSE, 3e3);
+          }
+        });
+      });
+      req.on("error", () => {
+        sseConnected = false;
+        setConnected(false);
+        if (!abort.signal.aborted) {
+          startPolling();
+          setTimeout(connectSSE, 3e3);
+        }
+      });
+    };
+    const pollAll = async () => {
+      const entries2 = await Promise.all(
+        queries.map(async (query2) => {
+          try {
+            const res = await fetch(`${serverUrl}/api/_control/query`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ query: query2 })
+            });
+            const json = await res.json();
+            if (json.ok) return [query2, { data: json.result }];
+            return [query2, { data: null, error: json.error }];
+          } catch (err) {
+            return [query2, { data: null, error: err instanceof Error ? err.message : String(err) }];
+          }
+        })
+      );
+      setResults(new Map(entries2));
+      setLoading(false);
+    };
+    const startPolling = () => {
+      if (fallbackTimerRef.current || sseConnected) return;
+      pollAll();
+      fallbackTimerRef.current = setInterval(pollAll, fallbackMs);
+    };
+    const stopPolling = () => {
+      if (fallbackTimerRef.current) {
+        clearInterval(fallbackTimerRef.current);
+        fallbackTimerRef.current = null;
+      }
+    };
+    connectSSE();
+    return () => {
+      abort.abort();
+      stopPolling();
+    };
+  }, [serverUrl, queriesKey, fallbackMs]);
+  const refresh = useCallback(async () => {
+    try {
+      await fetch(`${serverUrl}/api/_control/refresh`, { method: "POST" });
+    } catch {
+    }
+  }, [serverUrl]);
+  return { results, loading, connected, refresh };
+}
+
+// src/tui/hooks/useKeyboard.ts
+import { useInput, useApp } from "ink";
+function useKeyboard({ panelCount, focusedPanel, setFocusedPanel, onRefresh, onResize }) {
+  const { exit } = useApp();
+  useInput((input, key) => {
+    if (input === "q") exit();
+    if (input === "r") onRefresh?.();
+    if (key.tab && !key.shift) setFocusedPanel((i) => (i + 1) % panelCount);
+    if (key.tab && key.shift) setFocusedPanel((i) => (i - 1 + panelCount) % panelCount);
+    if (input === "]") onResize?.("grow");
+    if (input === "[") onResize?.("shrink");
+  });
+}
+
+// src/tui/components/Panel.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Panel({ title, focused = false, loading = false, error: error2, children }) {
+  const borderColor = focused ? "cyan" : "gray";
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      flexGrow: 1,
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      overflow: "hidden",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: focused ? "cyan" : void 0, children: title }),
+          loading && /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u21BB" })
+        ] }),
+        error2 ? /* @__PURE__ */ jsx(Text, { color: "red", children: error2 }) : children
+      ]
+    }
+  );
+}
+
+// src/tui/components/Table.tsx
+import { useState as useState2, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function formatValue(val) {
+  if (val == null) return "";
+  if (typeof val === "number") return Number.isInteger(val) ? String(val) : val.toFixed(2);
+  return String(val);
+}
+var SCROLLBAR_TRACK = "\u2502";
+var SCROLLBAR_THUMB = "\u2588";
+function Scrollbar({ totalRows, visibleRows, scrollOffset, height }) {
+  if (totalRows <= visibleRows) return null;
+  const thumbSize = Math.max(1, Math.round(visibleRows / totalRows * height));
+  const maxScroll = totalRows - visibleRows;
+  const thumbPosition = maxScroll > 0 ? Math.round(scrollOffset / maxScroll * (height - thumbSize)) : 0;
+  const lines = [];
+  for (let i = 0; i < height; i++) {
+    const isThumb = i >= thumbPosition && i < thumbPosition + thumbSize;
+    lines.push({ char: isThumb ? SCROLLBAR_THUMB : SCROLLBAR_TRACK, isThumb });
+  }
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginLeft: 1, children: lines.map((line, i) => /* @__PURE__ */ jsx2(Text2, { color: line.isThumb ? "#06b6d4" : "#333333", children: line.char }, i)) });
+}
+function Table({ data, maxRows = 20, focused = false }) {
+  const [scrollOffset, setScrollOffset] = useState2(0);
+  const prevDataLenRef = useRef2(data.length);
+  useEffect2(() => {
+    const maxOffset = Math.max(0, data.length - maxRows);
+    setScrollOffset((prev) => Math.min(prev, maxOffset));
+    prevDataLenRef.current = data.length;
+  }, [data.length, maxRows]);
+  useInput2((input, key) => {
+    if (!focused) return;
+    const maxOffset = Math.max(0, data.length - maxRows);
+    if (key.upArrow) setScrollOffset((o) => Math.max(0, o - 1));
+    if (key.downArrow) setScrollOffset((o) => Math.min(maxOffset, o + 1));
+    if (key.pageUp || input === "u" && key.ctrl) {
+      setScrollOffset((o) => Math.max(0, o - maxRows));
+    }
+    if (key.pageDown || input === "d" && key.ctrl) {
+      setScrollOffset((o) => Math.min(maxOffset, o + maxRows));
+    }
+  });
+  if (!data.length) return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "(empty)" });
+  const columns = Object.keys(data[0]);
+  const widths = columns.map((col) => {
+    const maxData = data.reduce((max, row) => Math.max(max, formatValue(row[col]).length), 0);
+    return Math.min(Math.max(col.length, maxData), 30);
+  });
+  const visibleRows = data.slice(scrollOffset, scrollOffset + maxRows);
+  const needsScroll = data.length > maxRows;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx2(Box2, { children: columns.map((col, i) => /* @__PURE__ */ jsx2(Box2, { width: widths[i] + 2, children: /* @__PURE__ */ jsx2(Text2, { bold: true, children: col.slice(0, widths[i]).padEnd(widths[i]) }) }, col)) }),
+        /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500") }) }),
+        visibleRows.map((row, ri) => /* @__PURE__ */ jsx2(Box2, { children: columns.map((col, i) => /* @__PURE__ */ jsx2(Box2, { width: widths[i] + 2, children: /* @__PURE__ */ jsx2(Text2, { color: typeof row[col] === "number" ? "#f59e0b" : void 0, children: formatValue(row[col]).slice(0, widths[i]).padEnd(widths[i]) }) }, col)) }, ri))
+      ] }),
+      needsScroll && /* @__PURE__ */ jsx2(
+        Scrollbar,
+        {
+          totalRows: data.length,
+          visibleRows: maxRows,
+          scrollOffset,
+          height: visibleRows.length + 2
+        }
+      )
+    ] }),
+    needsScroll && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      scrollOffset + 1,
+      "\u2013",
+      Math.min(scrollOffset + maxRows, data.length),
+      " of ",
+      data.length,
+      " rows",
+      focused ? " \u2502 \u2191\u2193 scroll" : ""
+    ] })
+  ] });
+}
+
+// src/tui/components/BarChart.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var BLOCK = "\u2588";
+var MAX_BAR_WIDTH = 40;
+function BarChart({ data, maxBars = 10 }) {
+  if (!data.length) return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "(empty)" });
+  const keys = Object.keys(data[0]);
+  const labelKey = keys[0];
+  const valueKey = keys.find((k) => typeof data[0][k] === "number") ?? keys[1];
+  const items = data.slice(0, maxBars).map((row) => ({
+    label: String(row[labelKey] ?? ""),
+    value: Number(row[valueKey]) || 0
+  }));
+  const maxValue = Math.max(...items.map((i) => i.value), 1);
+  const maxLabelLen = Math.max(...items.map((i) => i.label.length), 1);
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: items.map((item, i) => {
+    const barLen = Math.round(item.value / maxValue * MAX_BAR_WIDTH);
+    return /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        item.label.padEnd(maxLabelLen),
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: BLOCK.repeat(Math.max(1, barLen)) }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        " ",
+        formatNum(item.value)
+      ] })
+    ] }, i);
+  }) });
+}
+function formatNum(n) {
+  if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  return Number.isInteger(n) ? String(n) : n.toFixed(2);
+}
+
+// src/tui/components/StatBox.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function StatBox({ data }) {
+  let value;
+  if (Array.isArray(data) && data.length === 1 && typeof data[0] === "object" && data[0] !== null) {
+    const obj = data[0];
+    const firstVal = Object.values(obj)[0];
+    value = formatStat(firstVal);
+  } else if (typeof data === "number" || typeof data === "string") {
+    value = formatStat(data);
+  } else {
+    value = String(data);
+  }
+  return /* @__PURE__ */ jsx4(Box4, { justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx4(Text4, { bold: true, color: "green", children: value }) });
+}
+function formatStat(val) {
+  if (typeof val === "number") {
+    if (val >= 1e12) return (val / 1e12).toFixed(2) + "T";
+    if (val >= 1e9) return (val / 1e9).toFixed(2) + "B";
+    if (val >= 1e6) return (val / 1e6).toFixed(2) + "M";
+    if (val >= 1e3) return (val / 1e3).toFixed(2) + "K";
+    return Number.isInteger(val) ? String(val) : val.toFixed(2);
+  }
+  return String(val ?? "");
+}
+
+// src/tui/components/Sparkline.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var TICKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function Sparkline({ data, maxPoints = 60 }) {
+  if (!data.length) return /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(empty)" });
+  const keys = Object.keys(data[0]);
+  const labelKey = keys[0];
+  const valueKey = keys.find((k) => typeof data[0][k] === "number") ?? keys[1];
+  if (!valueKey) return /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(no numeric column)" });
+  const points = data.slice(-maxPoints);
+  const values = points.map((row) => Number(row[valueKey]) || 0);
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  const spark = values.map((v) => {
+    const level = Math.round((v - min) / range * (TICKS.length - 1));
+    return TICKS[Math.max(0, Math.min(TICKS.length - 1, level))];
+  }).join("");
+  const lastLabel = points.length > 0 ? String(points[points.length - 1][labelKey] ?? "") : "";
+  const lastValue = values[values.length - 1];
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: spark }) }),
+    /* @__PURE__ */ jsxs4(Box5, { gap: 2, children: [
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "min: ",
+        formatNum2(min)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "max: ",
+        formatNum2(max)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "last: ",
+        formatNum2(lastValue)
+      ] }),
+      lastLabel && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "(",
+        lastLabel,
+        ")"
+      ] })
+    ] })
+  ] });
+}
+function formatNum2(n) {
+  if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  return Number.isInteger(n) ? String(n) : n.toFixed(2);
+}
+
+// src/tui/components/OrderBook.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var BLOCK2 = "\u2588";
+var BAR_WIDTH = 20;
+var QTY_WIDTH = 10;
+var PRICE_WIDTH = 12;
+var ROWS = 10;
+function OrderBook({ data }) {
+  const entries2 = Array.isArray(data) ? data : [];
+  const latest = entries2[entries2.length - 1];
+  if (!latest || !latest.bids || !latest.asks) {
+    return /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Waiting for order book data..." });
+  }
+  const bids = latest.bids.slice(0, ROWS).map(([p, q]) => ({
+    price: parseFloat(p),
+    qty: parseFloat(q)
+  }));
+  const asks = latest.asks.slice(0, ROWS).map(([p, q]) => ({
+    price: parseFloat(p),
+    qty: parseFloat(q)
+  }));
+  const bidCum = [];
+  let sum = 0;
+  for (const b of bids) {
+    sum += b.qty;
+    bidCum.push(sum);
+  }
+  const askCum = [];
+  sum = 0;
+  for (const a of asks) {
+    sum += a.qty;
+    askCum.push(sum);
+  }
+  const bidMax = bidCum[bidCum.length - 1] || 1;
+  const askMax = askCum[askCum.length - 1] || 1;
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad("BIDS", BAR_WIDTH, "right") }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad("QTY", QTY_WIDTH, "left") }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad("PRICE", PRICE_WIDTH, "left") }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad("QTY", QTY_WIDTH, "left") }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "ASKS" })
+    ] }),
+    Array.from({ length: ROWS }, (_, i) => {
+      const bid = bids[i];
+      const ask = asks[i];
+      const bidWidth = bid ? Math.max(1, Math.round(bidCum[i] / bidMax * BAR_WIDTH)) : 0;
+      const askWidth = ask ? Math.max(1, Math.round(askCum[i] / askMax * BAR_WIDTH)) : 0;
+      return /* @__PURE__ */ jsxs5(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: BLOCK2.repeat(bidWidth).padStart(BAR_WIDTH) }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad(bid ? bid.qty.toFixed(4) : "", QTY_WIDTH, "left") }),
+        /* @__PURE__ */ jsx6(Text6, { bold: true, color: i < bids.length ? "green" : "red", children: pad(formatPrice(bid?.price ?? ask?.price ?? 0), PRICE_WIDTH, "left") }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: pad(ask ? ask.qty.toFixed(4) : "", QTY_WIDTH, "left") }),
+        /* @__PURE__ */ jsx6(Text6, { color: "red", children: BLOCK2.repeat(askWidth).padEnd(BAR_WIDTH) })
+      ] }, i);
+    }),
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Spread: " }),
+      /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: asks.length > 0 && bids.length > 0 ? `${(asks[0].price - bids[0].price).toFixed(2)} (${((asks[0].price - bids[0].price) / bids[0].price * 100).toFixed(4)}%)` : "\u2014" })
+    ] })
+  ] });
+}
+function pad(s, width, align) {
+  return align === "left" ? s.padStart(width) : s.padEnd(width);
+}
+function formatPrice(n) {
+  if (n >= 1e3) return n.toFixed(2);
+  if (n >= 1) return n.toFixed(4);
+  return n.toFixed(6);
+}
+
+// src/tui/components/Heatmap.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function Heatmap({ data }) {
+  if (!data.length) return /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "(empty)" });
+  const keys = Object.keys(data[0]);
+  const labelKey = keys[0];
+  const numericKeys = keys.filter((k) => {
+    const v = data[0][k];
+    return typeof v === "number" || typeof v === "string" && v !== "" && !isNaN(Number(v));
+  });
+  if (numericKeys.length === 0) return /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No numeric columns for heatmap" });
+  const ranges = /* @__PURE__ */ new Map();
+  for (const key of numericKeys) {
+    const vals = data.map((r) => Number(r[key]) || 0);
+    ranges.set(key, { min: Math.min(...vals), max: Math.max(...vals) });
+  }
+  const maxLabel = Math.max(...data.map((r) => String(r[labelKey] ?? "").length), 6);
+  const colWidth = 10;
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " ".repeat(maxLabel + 1) }),
+      numericKeys.map((k) => /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: k.slice(0, colWidth).padStart(colWidth) }, k))
+    ] }),
+    data.slice(0, 20).map((row, i) => /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: String(row[labelKey] ?? "").slice(0, maxLabel).padEnd(maxLabel) }),
+      /* @__PURE__ */ jsx7(Text7, { children: " " }),
+      numericKeys.map((k) => {
+        const val = Number(row[k]) || 0;
+        const range = ranges.get(k);
+        const norm = range.max === range.min ? 0.5 : (val - range.min) / (range.max - range.min);
+        const color = interpolateColor(norm);
+        const display = formatCell2(val);
+        return /* @__PURE__ */ jsx7(Text7, { backgroundColor: color, color: "white", children: display.padStart(colWidth) }, k);
+      })
+    ] }, i))
+  ] });
+}
+function interpolateColor(t) {
+  let r, g, b;
+  if (t < 0.5) {
+    const s = t * 2;
+    r = 180;
+    g = Math.round(s * 180);
+    b = 30;
+  } else {
+    const s = (t - 0.5) * 2;
+    r = Math.round(180 * (1 - s));
+    g = 180;
+    b = 30;
+  }
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function formatCell2(n) {
+  if (Math.abs(n) >= 1e9) return (n / 1e9).toFixed(1) + "B";
+  if (Math.abs(n) >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (Math.abs(n) >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  if (Number.isInteger(n)) return String(n);
+  return n.toFixed(2);
+}
+
+// src/tui/components/CandleChart.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var CHART_HEIGHT = 14;
+function CandleChart({ data }) {
+  if (!data.length) return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Waiting for candle data..." });
+  const candles = data.map((item) => {
+    const k = item.k;
+    if (!k) return null;
+    return {
+      open: parseFloat(k.o),
+      high: parseFloat(k.h),
+      low: parseFloat(k.l),
+      close: parseFloat(k.c),
+      time: k.t
+    };
+  }).filter((c) => c !== null);
+  const byTime = /* @__PURE__ */ new Map();
+  for (const c of candles) byTime.set(c.time, c);
+  const unique = [...byTime.values()].slice(-20);
+  if (unique.length === 0) return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Waiting for candle data..." });
+  const allHigh = Math.max(...unique.map((c) => c.high));
+  const allLow = Math.min(...unique.map((c) => c.low));
+  const priceRange = allHigh - allLow || 1;
+  const toRow = (price) => Math.min(CHART_HEIGHT - 1, Math.max(0, Math.round((allHigh - price) / priceRange * (CHART_HEIGHT - 1))));
+  const priceLabels = Array.from({ length: CHART_HEIGHT }, (_, row) => {
+    const price = allHigh - row / (CHART_HEIGHT - 1) * priceRange;
+    return formatPrice2(price);
+  });
+  const labelWidth = Math.max(...priceLabels.map((l) => l.length));
+  const rows = [];
+  for (let row = 0; row < CHART_HEIGHT; row++) {
+    const cells = [];
+    for (let col = 0; col < unique.length; col++) {
+      const c = unique[col];
+      const bullish = c.close >= c.open;
+      const color = bullish ? "green" : "red";
+      const bodyTop = toRow(Math.max(c.open, c.close));
+      const bodyBot = toRow(Math.min(c.open, c.close));
+      const wickTop = toRow(c.high);
+      const wickBot = toRow(c.low);
+      let char;
+      let cellColor;
+      if (row >= bodyTop && row <= bodyBot) {
+        char = "\u2588\u2588\u2588";
+        cellColor = color;
+      } else if (row >= wickTop && row <= wickBot) {
+        char = " \u2502 ";
+        cellColor = color;
+      } else {
+        char = "   ";
+        cellColor = "white";
+      }
+      cells.push(
+        /* @__PURE__ */ jsx8(Text8, { color: cellColor, children: char }, col)
+      );
+    }
+    rows.push(
+      /* @__PURE__ */ jsxs7(Box8, { children: [
+        /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+          priceLabels[row].padStart(labelWidth),
+          " "
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2502" }),
+        cells
+      ] }, row)
+    );
+  }
+  const latest = unique[unique.length - 1];
+  const oldest = unique[0];
+  const fmtTime = (t) => new Date(t).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const axisWidth = unique.length * 3;
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", children: [
+    rows,
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+      " ".repeat(labelWidth + 1),
+      "\u2514",
+      "\u2500".repeat(axisWidth)
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+      " ".repeat(labelWidth + 2),
+      fmtTime(oldest.time).padEnd(axisWidth - fmtTime(latest.time).length),
+      fmtTime(latest.time)
+    ] }) })
+  ] });
+}
+function formatPrice2(n) {
+  if (n >= 1e3) return n.toFixed(0);
+  if (n >= 1) return n.toFixed(2);
+  return n.toFixed(4);
+}
+
+// src/tui/components/Layout.tsx
+import { Box as Box9 } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function Layout({ panels, focusedIndex, colWeights, rowHeight, renderPanel }) {
+  const rows = [];
+  for (let i = 0; i < panels.length; i += 2) {
+    const row = [{ panel: panels[i], index: i }];
+    if (i + 1 < panels.length) {
+      row.push({ panel: panels[i + 1], index: i + 1 });
+    }
+    rows.push(row);
+  }
+  return /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", flexGrow: 1, children: rows.map((row, rowIdx) => /* @__PURE__ */ jsx9(Box9, { flexDirection: "row", height: rowHeight, children: row.map(({ panel, index }) => {
+    const width = row.length === 1 ? "100%" : `${colWeights[index]}%`;
+    return /* @__PURE__ */ jsx9(Box9, { width, minWidth: 20, children: renderPanel(panel, index, index === focusedIndex) }, index);
+  }) }, rowIdx)) });
+}
+
+// src/tui/components/StatusBar.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Box as Box10, Text as Text9 } from "ink";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function StatusBar({ serverUrl, refreshMs }) {
+  const [status, setStatus] = useState3(null);
+  useEffect3(() => {
+    const fetchStatus = async () => {
+      try {
+        const res = await fetch(`${serverUrl}/status`);
+        const data = await res.json();
+        setStatus({ uptime: data.uptime, sources: Object.keys(data.sources).length });
+      } catch {
+        setStatus(null);
+      }
+    };
+    fetchStatus();
+    const timer = setInterval(fetchStatus, refreshMs);
+    return () => clearInterval(timer);
+  }, [serverUrl, refreshMs]);
+  const uptimeStr = status ? formatUptime(status.uptime) : "\u2014";
+  const sourcesStr = status ? `${status.sources} source(s)` : "disconnected";
+  const refreshStr = `${Math.floor(refreshMs / 1e3)}s`;
+  return /* @__PURE__ */ jsxs8(Box10, { justifyContent: "space-between", paddingX: 1, borderStyle: "single", borderColor: "gray", borderTop: false, borderLeft: false, borderRight: false, children: [
+    /* @__PURE__ */ jsxs8(Box10, { gap: 2, children: [
+      /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+        "server: ",
+        serverUrl
+      ] }),
+      /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+        "uptime: ",
+        uptimeStr
+      ] }),
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: sourcesStr })
+    ] }),
+    /* @__PURE__ */ jsxs8(Box10, { gap: 2, children: [
+      /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+        "refresh: ",
+        refreshStr
+      ] }),
+      /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "q: quit  tab: focus  \u2191\u2193: scroll  []: resize  r: refresh" })
+    ] })
+  ] });
+}
+function formatUptime(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`;
+  return `${Math.floor(s / 3600)}h ${Math.floor(s % 3600 / 60)}m`;
+}
+
+// src/tui/App.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var MemoizedPanelContent = React3.memo(function PanelContent({ data, error: error2, viz, focused, loading, panelKey, maxTableRows }) {
+  if (error2) return /* @__PURE__ */ jsx11(Text10, { color: "red", children: error2 });
+  if (loading || data == null) return /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "Loading..." });
+  const rows = Array.isArray(data) ? data : [];
+  switch (viz) {
+    case "bar":
+      return /* @__PURE__ */ jsx11(BarChart, { data: rows });
+    case "stat":
+      return /* @__PURE__ */ jsx11(StatBox, { data });
+    case "sparkline":
+      return /* @__PURE__ */ jsx11(Sparkline, { data: rows });
+    case "orderbook":
+      return /* @__PURE__ */ jsx11(OrderBook, { data });
+    case "heatmap":
+      return /* @__PURE__ */ jsx11(Heatmap, { data: rows });
+    case "candle":
+      return /* @__PURE__ */ jsx11(CandleChart, { data: Array.isArray(data) ? data : [] });
+    case "table":
+      return /* @__PURE__ */ jsx11(Table, { data: rows, focused, maxRows: maxTableRows });
+    case "auto":
+    default:
+      if (!Array.isArray(data) || rows.length === 0) return /* @__PURE__ */ jsx11(StatBox, { data });
+      return /* @__PURE__ */ jsx11(Table, { data: rows, focused, maxRows: maxTableRows });
+  }
+});
+function App({ serverUrl, dashboard }) {
+  const [focusedPanel, setFocusedPanel] = useState4(0);
+  const { stdout } = useStdout();
+  const termHeight = stdout?.rows ?? 40;
+  const panels = dashboard.panels;
+  const refreshMs = dashboard.refresh ? parseDuration(dashboard.refresh) : 1e4;
+  const [colWeights, setColWeights] = useState4(
+    () => panels.map(() => 50)
+  );
+  const fixedOverhead = 3;
+  const numPanelRows = Math.ceil(panels.length / 2);
+  const rowHeight = Math.max(8, Math.floor((termHeight - fixedOverhead) / numPanelRows));
+  const panelOverhead = 5;
+  const maxTableRows = Math.max(3, rowHeight - panelOverhead);
+  const queries = useMemo(() => panels.map((p) => p.query), [panels]);
+  const { results, loading, connected, refresh } = useLiveData(serverUrl, queries, refreshMs);
+  const handleResize = useCallback2((direction) => {
+    setColWeights((prev) => {
+      const next = [...prev];
+      const rowStart = Math.floor(focusedPanel / 2) * 2;
+      const partner = focusedPanel % 2 === 0 ? focusedPanel + 1 : focusedPanel - 1;
+      if (partner < 0 || partner >= panels.length) return prev;
+      if (partner < rowStart || partner >= rowStart + 2) return prev;
+      const delta = direction === "grow" ? 5 : -5;
+      const newVal = Math.min(75, Math.max(25, next[focusedPanel] + delta));
+      next[focusedPanel] = newVal;
+      next[partner] = 100 - newVal;
+      return next;
+    });
+  }, [focusedPanel, panels.length]);
+  useKeyboard({
+    panelCount: panels.length,
+    focusedPanel,
+    setFocusedPanel,
+    onRefresh: refresh,
+    onResize: handleResize
+  });
+  const renderPanel = useCallback2((panel, index, focused) => {
+    const result = results.get(panel.query);
+    return /* @__PURE__ */ jsx11(Panel, { title: panel.title, focused, children: /* @__PURE__ */ jsx11(
+      MemoizedPanelContent,
+      {
+        panelKey: `panel-${index}`,
+        data: result?.data ?? null,
+        error: result?.error,
+        viz: panel.viz,
+        focused,
+        loading: loading && !result,
+        maxTableRows
+      }
+    ) });
+  }, [results, loading, maxTableRows]);
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: termHeight, children: [
+    /* @__PURE__ */ jsxs9(Box11, { justifyContent: "center", paddingX: 1, children: [
+      /* @__PURE__ */ jsx11(Text10, { bold: true, color: "cyan", children: "PipeQuery Dashboard" }),
+      connected && /* @__PURE__ */ jsx11(Text10, { color: "green", children: " \u25CF LIVE" }),
+      !connected && !loading && /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: " \u25CB polling" })
+    ] }),
+    /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: /* @__PURE__ */ jsx11(
+      Layout,
+      {
+        panels,
+        focusedIndex: focusedPanel,
+        colWeights,
+        rowHeight,
+        renderPanel
+      }
+    ) }),
+    /* @__PURE__ */ jsx11(StatusBar, { serverUrl, refreshMs })
+  ] });
+}
+
+// src/utils/sync-output.ts
+var BEGIN_SYNC = "\x1B[?2026h";
+var END_SYNC = "\x1B[?2026l";
+var patched = false;
+var pendingTimer = null;
+var inSync = false;
+function enableSyncOutput() {
+  if (patched) return;
+  patched = true;
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function(chunk, encodingOrCallback, callback) {
+    if (!inSync) {
+      inSync = true;
+      originalWrite(BEGIN_SYNC);
+    }
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+    }
+    pendingTimer = setTimeout(() => {
+      originalWrite(END_SYNC);
+      inSync = false;
+      pendingTimer = null;
+    }, 0);
+    return originalWrite(chunk, encodingOrCallback, callback);
+  };
+}
+function disableSyncOutput() {
+  if (inSync) {
+    process.stdout.write("\x1B[?2026l");
+    inSync = false;
+  }
+  if (pendingTimer) {
+    clearTimeout(pendingTimer);
+    pendingTimer = null;
+  }
+}
+
+// src/commands/dashboard.ts
+async function dashboardCommand(opts) {
+  const dashboardName = opts.name ?? "main";
+  const cwd = process.cwd();
+  const { config } = await loadConfig(cwd);
+  const dashboard = config.dashboards[dashboardName];
+  if (!dashboard) {
+    log.error(`Dashboard "${dashboardName}" not found in config.`);
+    const available = Object.keys(config.dashboards);
+    if (available.length > 0) {
+      log.info(`Available dashboards: ${available.join(", ")}`);
+    } else {
+      log.dim("Add a dashboard section to pipequery.yaml");
+    }
+    return;
+  }
+  const serverUrl = await getServerUrl();
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[?25l");
+  enableSyncOutput();
+  const { waitUntilExit } = render(
+    React4.createElement(App, { serverUrl, dashboard }),
+    { patchConsole: false }
+  );
+  await waitUntilExit();
+  disableSyncOutput();
+  process.stdout.write("\x1B[?25h");
+  process.stdout.write("\x1B[?1049l");
+}
+
+// src/commands/monitor.ts
+import React6 from "react";
+import { render as render2 } from "ink";
+import { existsSync as existsSync5, readFileSync } from "fs";
+import { resolve as resolve6 } from "path";
+
+// src/tui/MonitorApp.tsx
+import { useState as useState5, useEffect as useEffect4 } from "react";
+import { Box as Box12, Text as Text11, useApp as useApp2, useInput as useInput3 } from "ink";
+import { Fragment, jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function useServerStatus(serverUrl, refreshMs) {
+  const [info2, setInfo] = useState5(null);
+  const [connected, setConnected] = useState5(false);
+  useEffect4(() => {
+    const fetchStatus = async () => {
+      try {
+        const res = await fetch(`${serverUrl}/status`);
+        const data = await res.json();
+        setInfo(data);
+        setConnected(true);
+      } catch {
+        setInfo(null);
+        setConnected(false);
+      }
+    };
+    fetchStatus();
+    const timer = setInterval(fetchStatus, refreshMs);
+    return () => clearInterval(timer);
+  }, [serverUrl, refreshMs]);
+  return { info: info2, connected };
+}
+function useEndpoints(serverUrl, refreshMs) {
+  const [endpoints, setEndpoints] = useState5({});
+  useEffect4(() => {
+    const fetchEndpoints = async () => {
+      try {
+        const res = await fetch(`${serverUrl}/api/_control/endpoints`);
+        const data = await res.json();
+        setEndpoints(data);
+      } catch {
+      }
+    };
+    fetchEndpoints();
+    const timer = setInterval(fetchEndpoints, refreshMs);
+    return () => clearInterval(timer);
+  }, [serverUrl, refreshMs]);
+  return endpoints;
+}
+function useActivityLog(serverUrl, refreshMs, maxLines) {
+  const [entries2, setEntries] = useState5([]);
+  useEffect4(() => {
+    const fetchActivity = async () => {
+      try {
+        const res = await fetch(`${serverUrl}/api/_control/activity`);
+        const data = await res.json();
+        setEntries(data.slice(-maxLines));
+      } catch {
+      }
+    };
+    fetchActivity();
+    const timer = setInterval(fetchActivity, refreshMs);
+    return () => clearInterval(timer);
+  }, [serverUrl, refreshMs, maxLines]);
+  return entries2;
+}
+function Header({ connected, uptime }) {
+  return /* @__PURE__ */ jsxs10(Box12, { paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs10(Box12, { gap: 1, children: [
+      /* @__PURE__ */ jsx12(Text11, { bold: true, color: "#06b6d4", children: "\u2B21" }),
+      /* @__PURE__ */ jsx12(Text11, { bold: true, color: "#06b6d4", children: "PipeQuery Monitor" })
+    ] }),
+    /* @__PURE__ */ jsxs10(Box12, { gap: 2, children: [
+      /* @__PURE__ */ jsx12(Text11, { color: connected ? "#22c55e" : "#ef4444", children: connected ? "\u25CF connected" : "\u25CF disconnected" }),
+      /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
+        "uptime: ",
+        formatUptime2(uptime)
+      ] })
+    ] })
+  ] });
+}
+function SourcesPanel({ sources }) {
+  const entries2 = Object.entries(sources);
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "#4f46e5", paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Box12, { marginBottom: 0, children: /* @__PURE__ */ jsxs10(Text11, { bold: true, color: "#4f46e5", children: [
+      " Sources (",
+      entries2.length,
+      ") "
+    ] }) }),
+    entries2.length === 0 ? /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "  No sources configured" }) : /* @__PURE__ */ jsxs10(Fragment, { children: [
+      /* @__PURE__ */ jsxs10(Box12, { children: [
+        /* @__PURE__ */ jsx12(Box12, { width: 20, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "NAME" }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "STATUS" }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "ROWS" }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 22, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "LAST FETCH" }) }),
+        /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "ERROR" }) })
+      ] }),
+      entries2.map(([name, status]) => /* @__PURE__ */ jsxs10(Box12, { children: [
+        /* @__PURE__ */ jsx12(Box12, { width: 20, children: /* @__PURE__ */ jsx12(Text11, { color: "#06b6d4", children: name }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { color: status.healthy ? "#22c55e" : "#ef4444", children: status.healthy ? "\u2713 ok" : "\u2717 err" }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { children: String(status.rowCount) }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 22, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: status.lastFetch ? new Date(status.lastFetch).toLocaleTimeString() : "\u2014" }) }),
+        /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsx12(Text11, { color: "#ef4444", children: status.error ?? "" }) })
+      ] }, name))
+    ] })
+  ] });
+}
+function EndpointsPanel({ endpoints, serverUrl }) {
+  const entries2 = Object.entries(endpoints);
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "#7c3aed", paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Box12, { marginBottom: 0, children: /* @__PURE__ */ jsxs10(Text11, { bold: true, color: "#7c3aed", children: [
+      " Endpoints (",
+      entries2.length,
+      ") "
+    ] }) }),
+    entries2.length === 0 ? /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "  No endpoints registered" }) : /* @__PURE__ */ jsxs10(Fragment, { children: [
+      /* @__PURE__ */ jsxs10(Box12, { children: [
+        /* @__PURE__ */ jsx12(Box12, { width: 30, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "PATH" }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "CACHE" }) }),
+        /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, bold: true, children: "QUERY" }) })
+      ] }),
+      entries2.map(([path, config]) => /* @__PURE__ */ jsxs10(Box12, { children: [
+        /* @__PURE__ */ jsx12(Box12, { width: 30, children: /* @__PURE__ */ jsxs10(Text11, { color: "#06b6d4", children: [
+          serverUrl,
+          path
+        ] }) }),
+        /* @__PURE__ */ jsx12(Box12, { width: 10, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: config.cache ?? "\u2014" }) }),
+        /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsx12(Text11, { children: config.query }) })
+      ] }, path))
+    ] })
+  ] });
+}
+function ActivityPanel({ entries: entries2 }) {
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Box12, { marginBottom: 0, children: /* @__PURE__ */ jsx12(Text11, { bold: true, color: "gray", children: " Activity Log " }) }),
+    entries2.length === 0 ? /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "  No activity yet \u2014 run queries, add sources, or hit endpoints" }) : entries2.map((entry, i) => {
+      const time = new Date(entry.time).toLocaleTimeString();
+      const levelColor = entry.level === "error" ? "#ef4444" : entry.level === "warn" ? "#f59e0b" : "#22c55e";
+      const levelIcon = entry.level === "error" ? "\u2717" : entry.level === "warn" ? "\u26A0" : "\u2192";
+      return /* @__PURE__ */ jsxs10(Box12, { gap: 1, children: [
+        /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: time }),
+        /* @__PURE__ */ jsx12(Text11, { color: levelColor, children: levelIcon }),
+        /* @__PURE__ */ jsx12(Text11, { color: entry.level === "error" ? "#ef4444" : void 0, children: entry.message })
+      ] }, i);
+    })
+  ] });
+}
+function HelpBar() {
+  return /* @__PURE__ */ jsxs10(Box12, { paddingX: 1, justifyContent: "center", gap: 3, children: [
+    /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "q: quit" }),
+    /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "r: refresh" }),
+    /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "auto-refresh: 2s" })
+  ] });
+}
+function formatUptime2(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`;
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  return `${h}h ${m}m`;
+}
+function MonitorApp({ serverUrl }) {
+  const { exit } = useApp2();
+  const { info: info2, connected } = useServerStatus(serverUrl, 2e3);
+  const endpoints = useEndpoints(serverUrl, 5e3);
+  const activityEntries = useActivityLog(serverUrl, 2e3, 15);
+  const [, setTick] = useState5(0);
+  useInput3((input) => {
+    if (input === "q") exit();
+    if (input === "r") setTick((t) => t + 1);
+  });
+  const sources = info2?.sources ?? {};
+  const uptime = info2?.uptime ?? 0;
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", padding: 0, children: [
+    /* @__PURE__ */ jsx12(Header, { connected, uptime }),
+    /* @__PURE__ */ jsx12(Box12, { height: 1 }),
+    /* @__PURE__ */ jsx12(SourcesPanel, { sources }),
+    /* @__PURE__ */ jsx12(Box12, { height: 1 }),
+    /* @__PURE__ */ jsx12(EndpointsPanel, { endpoints, serverUrl }),
+    /* @__PURE__ */ jsx12(Box12, { height: 1 }),
+    /* @__PURE__ */ jsx12(ActivityPanel, { entries: activityEntries }),
+    /* @__PURE__ */ jsx12(HelpBar, {})
+  ] });
+}
+
+// src/commands/monitor.ts
+async function monitorCommand() {
+  const serverUrl = await getServerUrl();
+  const discoveryPath = resolve6(process.cwd(), ".pipequery", "server.json");
+  let logPath;
+  if (existsSync5(discoveryPath)) {
+    try {
+      const disc = JSON.parse(readFileSync(discoveryPath, "utf-8"));
+      if (disc.log && existsSync5(disc.log)) {
+        logPath = disc.log;
+      }
+    } catch {
+    }
+  }
+  if (!logPath) {
+    const fallback = resolve6(process.cwd(), ".pipequery", "server.log");
+    if (existsSync5(fallback)) {
+      logPath = fallback;
+    }
+  }
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[?25l");
+  enableSyncOutput();
+  const { waitUntilExit } = render2(
+    React6.createElement(MonitorApp, { serverUrl, logPath }),
+    { patchConsole: false }
+  );
+  await waitUntilExit();
+  disableSyncOutput();
+  process.stdout.write("\x1B[?25h");
+  process.stdout.write("\x1B[?1049l");
+}
+
+// src/commands/remote.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+
+// src/docker/templates.ts
+function generateDockerfile(port) {
+  return `FROM node:20-alpine
+WORKDIR /app
+
+# Copy config and data files
+COPY pipequery.yaml .
+COPY data/ data/ 2>/dev/null || true
+
+# Install PipeQuery CLI
+RUN npm install -g @andreadito/pq
+
+EXPOSE ${port}
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \\
+  CMD wget -qO- http://localhost:${port}/health || exit 1
+
+CMD ["pq", "serve", "--host", "0.0.0.0"]
+`;
+}
+function generateDockerCompose(port) {
+  return `services:
+  pipequery:
+    build: .
+    ports:
+      - "${port}:${port}"
+    volumes:
+      - ./pipequery.yaml:/app/pipequery.yaml:ro
+      - ./data:/app/data:ro
+    restart: unless-stopped
+    environment:
+      - NODE_ENV=production
+`;
+}
+function generateDockerignore() {
+  return `node_modules
+.pipequery
+.git
+*.log
+dist
+`;
+}
+
+// src/commands/remote.ts
+async function remoteDeployCommand() {
+  const cwd = process.cwd();
+  const { config } = await loadConfig(cwd);
+  const port = config.server.port;
+  await writeFile4(resolve7(cwd, "Dockerfile"), generateDockerfile(port));
+  await writeFile4(resolve7(cwd, "docker-compose.yaml"), generateDockerCompose(port));
+  await writeFile4(resolve7(cwd, ".dockerignore"), generateDockerignore());
+  log.success("Generated Dockerfile, docker-compose.yaml, and .dockerignore");
+  log.info(`Run: docker compose up -d --build`);
+  log.info(`Then: pq remote connect http://localhost:${port}`);
+}
+async function loadOrCreateConfig(cwd) {
+  const existing = findConfigPath(cwd);
+  if (existing) {
+    return loadConfig(cwd);
+  }
+  const configPath = resolve7(cwd, "pipequery.yaml");
+  const config = {
+    server: { ...DEFAULT_CONFIG.server },
+    sources: {},
+    endpoints: {},
+    dashboards: {}
+  };
+  await saveConfig(config, configPath);
+  return { config, path: configPath };
+}
+async function remoteConnectCommand(url) {
+  try {
+    const res = await fetch(`${url}/health`);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  } catch (err) {
+    log.error(`Cannot reach ${url}: ${err instanceof Error ? err.message : err}`);
+    return;
+  }
+  const cwd = process.cwd();
+  const { config, path: configPath } = await loadOrCreateConfig(cwd);
+  config.remote = { url };
+  await saveConfig(config, configPath);
+  log.success(`Connected to remote server at ${url}`);
+}
+async function remoteStatusCommand() {
+  const cwd = process.cwd();
+  const existing = findConfigPath(cwd);
+  if (!existing) {
+    log.error("No remote server configured. Use: pq remote connect <url>");
+    return;
+  }
+  const { config } = await loadConfig(cwd);
+  const url = config.remote?.url;
+  if (!url) {
+    log.error("No remote server configured. Use: pq remote connect <url>");
+    return;
+  }
+  try {
+    const res = await fetch(`${url}/status`);
+    const status = await res.json();
+    log.success(`Remote server at ${url}`);
+    log.info(`Uptime: ${Math.floor(status.uptime / 1e3)}s`);
+    log.info(`Sources: ${Object.keys(status.sources).length}`);
+  } catch (err) {
+    log.error(`Cannot reach ${url}: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/commands/completion.ts
+var BASH_COMPLETION = `###-begin-pq-completions-###
+_pq_completions() {
+  local cur prev commands source_cmds endpoint_cmds remote_cmds
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  commands="init serve query source endpoint dashboard remote help"
+  source_cmds="list add remove test"
+  endpoint_cmds="list add remove"
+  remote_cmds="deploy connect status"
+
+  case "\${COMP_WORDS[1]}" in
+    source)
+      COMPREPLY=( $(compgen -W "$source_cmds" -- "$cur") )
+      return 0
+      ;;
+    endpoint)
+      COMPREPLY=( $(compgen -W "$endpoint_cmds" -- "$cur") )
+      return 0
+      ;;
+    remote)
+      COMPREPLY=( $(compgen -W "$remote_cmds" -- "$cur") )
+      return 0
+      ;;
+    serve)
+      COMPREPLY=( $(compgen -W "--port --host --daemon --stop" -- "$cur") )
+      return 0
+      ;;
+    query)
+      COMPREPLY=( $(compgen -W "--format" -- "$cur") )
+      return 0
+      ;;
+    dashboard)
+      COMPREPLY=( $(compgen -W "--name" -- "$cur") )
+      return 0
+      ;;
+  esac
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+  fi
+
+  return 0
+}
+complete -F _pq_completions pq
+###-end-pq-completions-###`;
+var ZSH_COMPLETION = `###-begin-pq-completions-###
+_pq() {
+  local -a commands source_cmds endpoint_cmds remote_cmds
+
+  commands=(
+    'init:Create a pipequery.yaml config file'
+    'serve:Start the PipeQuery server'
+    'query:Run an ad-hoc PipeQuery expression'
+    'source:Manage data sources'
+    'endpoint:Manage API endpoints'
+    'dashboard:Launch the interactive terminal dashboard'
+    'remote:Manage remote deployment'
+  )
+
+  source_cmds=(
+    'list:List configured data sources'
+    'add:Add a data source'
+    'remove:Remove a data source'
+    'test:Test a data source'
+  )
+
+  endpoint_cmds=(
+    'list:List API endpoints'
+    'add:Register an API endpoint'
+    'remove:Remove an API endpoint'
+  )
+
+  remote_cmds=(
+    'deploy:Generate Dockerfile and docker-compose.yaml'
+    'connect:Connect CLI to a remote PipeQuery server'
+    'status:Check remote server health'
+  )
+
+  _arguments -C \\
+    '1: :->command' \\
+    '2: :->subcommand' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _describe 'command' commands
+      ;;
+    subcommand)
+      case $words[2] in
+        source) _describe 'subcommand' source_cmds ;;
+        endpoint) _describe 'subcommand' endpoint_cmds ;;
+        remote) _describe 'subcommand' remote_cmds ;;
+      esac
+      ;;
+  esac
+}
+compdef _pq pq
+###-end-pq-completions-###`;
+var FISH_COMPLETION = `###-begin-pq-completions-###
+# Top-level commands
+complete -c pq -f -n '__fish_use_subcommand' -a 'init' -d 'Create a pipequery.yaml config file'
+complete -c pq -f -n '__fish_use_subcommand' -a 'serve' -d 'Start the PipeQuery server'
+complete -c pq -f -n '__fish_use_subcommand' -a 'query' -d 'Run an ad-hoc PipeQuery expression'
+complete -c pq -f -n '__fish_use_subcommand' -a 'source' -d 'Manage data sources'
+complete -c pq -f -n '__fish_use_subcommand' -a 'endpoint' -d 'Manage API endpoints'
+complete -c pq -f -n '__fish_use_subcommand' -a 'dashboard' -d 'Launch the terminal dashboard'
+complete -c pq -f -n '__fish_use_subcommand' -a 'remote' -d 'Manage remote deployment'
+
+# source subcommands
+complete -c pq -f -n '__fish_seen_subcommand_from source' -a 'list' -d 'List data sources'
+complete -c pq -f -n '__fish_seen_subcommand_from source' -a 'add' -d 'Add a data source'
+complete -c pq -f -n '__fish_seen_subcommand_from source' -a 'remove' -d 'Remove a data source'
+complete -c pq -f -n '__fish_seen_subcommand_from source' -a 'test' -d 'Test a data source'
+
+# endpoint subcommands
+complete -c pq -f -n '__fish_seen_subcommand_from endpoint' -a 'list' -d 'List endpoints'
+complete -c pq -f -n '__fish_seen_subcommand_from endpoint' -a 'add' -d 'Add an endpoint'
+complete -c pq -f -n '__fish_seen_subcommand_from endpoint' -a 'remove' -d 'Remove an endpoint'
+
+# remote subcommands
+complete -c pq -f -n '__fish_seen_subcommand_from remote' -a 'deploy' -d 'Generate Docker files'
+complete -c pq -f -n '__fish_seen_subcommand_from remote' -a 'connect' -d 'Connect to remote server'
+complete -c pq -f -n '__fish_seen_subcommand_from remote' -a 'status' -d 'Check remote health'
+
+# serve flags
+complete -c pq -l port -s p -n '__fish_seen_subcommand_from serve' -d 'Server port'
+complete -c pq -l host -s H -n '__fish_seen_subcommand_from serve' -d 'Server host'
+complete -c pq -l daemon -s d -n '__fish_seen_subcommand_from serve' -d 'Run as daemon'
+complete -c pq -l stop -n '__fish_seen_subcommand_from serve' -d 'Stop running daemon'
+###-end-pq-completions-###`;
+async function completionCommand(opts) {
+  const shell = opts.shell ?? detectShell();
+  switch (shell) {
+    case "bash":
+      console.log(BASH_COMPLETION);
+      log.dim("\n# Add to ~/.bashrc:");
+      log.dim('# eval "$(pq completion --shell bash)"');
+      break;
+    case "zsh":
+      console.log(ZSH_COMPLETION);
+      log.dim("\n# Add to ~/.zshrc:");
+      log.dim('# eval "$(pq completion --shell zsh)"');
+      break;
+    case "fish":
+      console.log(FISH_COMPLETION);
+      log.dim("\n# Save to ~/.config/fish/completions/pq.fish:");
+      log.dim("# pq completion --shell fish > ~/.config/fish/completions/pq.fish");
+      break;
+    default:
+      log.error(`Unknown shell: ${shell}. Use --shell bash|zsh|fish`);
+  }
+}
+function detectShell() {
+  const shell = process.env.SHELL ?? "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("fish")) return "fish";
+  return "bash";
+}
+
+// src/commands/stop.ts
+import { readFile as readFile5, unlink as unlink2 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+import { existsSync as existsSync6 } from "fs";
+async function stopCommand(opts) {
+  const cwd = process.cwd();
+  const serverJsonPath = resolve8(cwd, ".pipequery", "server.json");
+  if (!existsSync6(serverJsonPath)) {
+    log.error("No running server found.");
+    log.dim("Start one with: pq serve  or  pq serve -d");
+    return;
+  }
+  let info2;
+  try {
+    info2 = JSON.parse(await readFile5(serverJsonPath, "utf-8"));
+  } catch {
+    log.error("Could not read server info. Cleaning up stale file.");
+    try {
+      await unlink2(serverJsonPath);
+    } catch {
+    }
+    return;
+  }
+  let alive = false;
+  try {
+    process.kill(info2.pid, 0);
+    alive = true;
+  } catch {
+  }
+  if (!alive) {
+    log.warn(`Server (PID: ${info2.pid}) is not running. Cleaning up stale state.`);
+    try {
+      await unlink2(serverJsonPath);
+    } catch {
+    }
+    return;
+  }
+  const signal = opts.force ? "SIGKILL" : "SIGTERM";
+  try {
+    process.kill(info2.pid, signal);
+    log.success(`Server stopped (PID: ${info2.pid})${info2.daemon ? " [daemon]" : ""}`);
+  } catch (err) {
+    log.error(`Failed to stop server: ${err instanceof Error ? err.message : err}`);
+  }
+  try {
+    await unlink2(serverJsonPath);
+  } catch {
+  }
+}
+
+// src/commands/repl.ts
+import { createInterface } from "readline";
+import { spawnSync } from "child_process";
+import chalk7 from "chalk";
+var COMMANDS = {
+  help: "Show available commands",
+  serve: "Start the server (serve -d for daemon, serve --stop to stop)",
+  query: "Run a PipeQuery expression (e.g. query products | first(5))",
+  sources: "List data sources",
+  endpoints: "List API endpoints",
+  status: "Show server status",
+  dashboard: "Launch the interactive TUI dashboard",
+  monitor: "Launch the live server monitor",
+  clear: "Clear the screen",
+  exit: "Exit the REPL"
+};
+async function startRepl() {
+  printCompactBanner();
+  let serverUrl = null;
+  try {
+    serverUrl = await getServerUrl();
+    log.success(`Connected to server at ${chalk7.white.bold(serverUrl)}`);
+  } catch {
+    log.warn("No running server found. Start one with: pq serve");
+  }
+  console.log(chalk7.dim('  Type "help" for available commands, "exit" to quit.\n'));
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk7.hex("#06b6d4").bold("  pq > "),
+    terminal: true
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    const [cmd, ...rest] = input.split(/\s+/);
+    const args = rest.join(" ");
+    try {
+      switch (cmd) {
+        case "help":
+          console.log();
+          for (const [name, desc] of Object.entries(COMMANDS)) {
+            console.log(`  ${chalk7.hex("#06b6d4")(name.padEnd(12))} ${chalk7.dim(desc)}`);
+          }
+          console.log();
+          break;
+        case "query":
+        case "q":
+          if (!args) {
+            log.warn("Usage: query <expression>");
+            break;
+          }
+          if (!serverUrl) {
+            log.error("No server running. Start one with: pq serve");
+            break;
+          }
+          await runQuery(serverUrl, args);
+          break;
+        case "sources":
+          if (!serverUrl) {
+            log.error("No server running.");
+            break;
+          }
+          await fetchAndPrint(serverUrl, "/api/_control/sources", "sources");
+          break;
+        case "endpoints":
+          if (!serverUrl) {
+            log.error("No server running.");
+            break;
+          }
+          await fetchAndPrint(serverUrl, "/api/_control/endpoints", "endpoints");
+          break;
+        case "status":
+          if (!serverUrl) {
+            log.error("No server running.");
+            break;
+          }
+          await fetchAndPrint(serverUrl, "/status", null);
+          break;
+        case "serve": {
+          const serveArgs = ["serve"];
+          if (args) serveArgs.push(...args.split(/\s+/));
+          rl.pause();
+          spawnSync(process.execPath, [process.argv[1], ...serveArgs], {
+            cwd: process.cwd(),
+            stdio: "inherit"
+          });
+          try {
+            serverUrl = await getServerUrl();
+            log.success(`Connected to server at ${chalk7.white.bold(serverUrl)}`);
+          } catch {
+          }
+          rl.resume();
+          break;
+        }
+        case "dashboard":
+          rl.pause();
+          spawnSync(process.execPath, [process.argv[1], "dashboard", "-n", args || "main"], {
+            cwd: process.cwd(),
+            stdio: "inherit"
+          });
+          rl.resume();
+          break;
+        case "monitor":
+          rl.pause();
+          spawnSync(process.execPath, [process.argv[1], "monitor"], {
+            cwd: process.cwd(),
+            stdio: "inherit"
+          });
+          rl.resume();
+          break;
+        case "clear":
+          process.stdout.write("\x1B[2J\x1B[H");
+          printCompactBanner();
+          break;
+        case "exit":
+        case "quit":
+          console.log(chalk7.dim("  Goodbye.\n"));
+          rl.close();
+          process.exit(0);
+          break;
+        default:
+          log.warn(`Unknown command: ${cmd}. Type "help" for available commands.`);
+      }
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err));
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+async function runQuery(serverUrl, expression) {
+  const res = await fetch(`${serverUrl}/api/_control/query`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: expression })
+  });
+  const json = await res.json();
+  if (!json.ok) {
+    log.error(json.error ?? "Query failed");
+    return;
+  }
+  const result = json.result;
+  if (Array.isArray(result) && result.length > 0 && typeof result[0] === "object") {
+    printTable(result);
+  } else {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+function printTable(rows) {
+  if (rows.length === 0) {
+    log.dim("(empty result)");
+    return;
+  }
+  const columns = Object.keys(rows[0]);
+  const widths = columns.map((col) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, formatCell3(row[col]).length), 0);
+    return Math.max(col.length, maxData);
+  });
+  const header = columns.map((col, i) => chalk7.hex("#06b6d4").bold(col.padEnd(widths[i]))).join("  ");
+  const separator = widths.map((w) => chalk7.dim("\u2500".repeat(w))).join(chalk7.dim("\u2500\u2500"));
+  console.log();
+  console.log(`  ${header}`);
+  console.log(`  ${separator}`);
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const val = formatCell3(row[col]);
+      return typeof row[col] === "number" ? chalk7.hex("#f59e0b")(val.padStart(widths[i])) : val.padEnd(widths[i]);
+    }).join("  ");
+    console.log(`  ${line}`);
+  }
+  console.log();
+  console.log(chalk7.dim(`  ${rows.length} row(s)`));
+  console.log();
+}
+function formatCell3(value) {
+  if (value == null) return "";
+  if (typeof value === "number") return Number.isInteger(value) ? String(value) : value.toFixed(2);
+  return String(value);
+}
+async function fetchAndPrint(serverUrl, path, key) {
+  const res = await fetch(`${serverUrl}${path}`);
+  const json = await res.json();
+  const data = key ? json[key] : json;
+  console.log();
+  console.log(JSON.stringify(data, null, 2));
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("pq").description("PipeQuery CLI \u2014 data sources, aggregations, APIs, and terminal dashboards").version("0.1.0").addHelpText("beforeAll", () => {
+  printBanner();
+  return "";
+}).configureHelp({
+  subcommandTerm: (cmd) => chalk8.hex("#06b6d4")(cmd.name()) + (cmd.usage() ? " " + chalk8.dim(cmd.usage()) : "")
+});
+program.command("init").description("Create a pipequery.yaml config file").action(initCommand);
+program.command("serve").description("Start the PipeQuery server").option("-p, --port <port>", "Server port", parseInt).option("-H, --host <host>", "Server host").option("-d, --daemon", "Run as a background daemon").option("--stop", "Stop a running daemon").action(serveCommand);
+program.command("query <expression>").description("Run an ad-hoc PipeQuery expression").option("-f, --format <format>", "Output format: table, json", "table").action(queryCommand);
+var source = program.command("source").description("Manage data sources");
+source.command("list").description("List configured data sources").action(sourceListCommand);
+source.command("add <name>").description("Add a data source").requiredOption("-t, --type <type>", "Source type: rest, websocket, file").option("-u, --url <url>", "URL for REST or WebSocket sources").option("-i, --interval <interval>", "Poll interval for REST (e.g., 30s, 5m)", "30s").option("-d, --data-path <path>", "Dot-path to extract data from response").option("-p, --path <path>", "File path for file sources").option("-w, --watch", "Watch file for changes").action(sourceAddCommand);
+source.command("remove <name>").description("Remove a data source").action(sourceRemoveCommand);
+source.command("test <name>").description("Test a data source and show sample data").action(sourceTestCommand);
+var endpoint = program.command("endpoint").description("Manage API endpoints");
+endpoint.command("list").description("List API endpoints").action(endpointListCommand);
+endpoint.command("add <path>").description("Register an API endpoint").requiredOption("-q, --query <query>", "PipeQuery expression").option("-c, --cache <duration>", "Cache duration (e.g., 30s)").action(endpointAddCommand);
+endpoint.command("remove <path>").description("Remove an API endpoint").action(endpointRemoveCommand);
+program.command("dashboard").description("Launch the interactive terminal dashboard").option("-n, --name <name>", "Dashboard name from config", "main").action(dashboardCommand);
+program.command("monitor").description("Live server monitor \u2014 sources, endpoints, logs").action(monitorCommand);
+var remote = program.command("remote").description("Manage remote deployment");
+remote.command("deploy").description("Generate Dockerfile and docker-compose.yaml").action(remoteDeployCommand);
+remote.command("connect <url>").description("Connect CLI to a remote PipeQuery server").action(remoteConnectCommand);
+remote.command("status").description("Check remote server health").action(remoteStatusCommand);
+program.command("stop").description("Stop the running PipeQuery server (daemon or foreground)").option("-f, --force", "Force kill (SIGKILL instead of SIGTERM)").action(stopCommand);
+program.command("completion").description("Generate shell completion script").option("-s, --shell <shell>", "Shell type: bash, zsh, fish").action(completionCommand);
+if (process.argv.length <= 2) {
+  startRepl();
+} else {
+  program.parse();
+}