@graphenedata/cli 0.0.4 → 0.0.6

package/dist/cli/cli.js

@@ -58,8 +58,18 @@ function walkExpression(root, fn, parent = null) {
     });
   }
 }
+async function pollFor(fn, timeoutMs, interval) {
+  let end = Date.now() + timeoutMs;
+  while (Date.now() < end) {
+    let res = fn();
+    if (res) return res;
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  return null;
+}
 var init_util = __esm({
   "../lang/util.ts"() {
+    "use strict";
   }
 });
 
@@ -126,6 +136,7 @@ function extractLeadingMetadata(node) {
 }
 var init_metadata = __esm({
   "../lang/metadata.ts"() {
+    "use strict";
     init_util();
   }
 });
@@ -134,8 +145,12 @@ var init_metadata = __esm({
 import * as fs from "fs";
 import path from "path";
 function setConfig(cfg) {
+  let dialect = cfg.dialect || "duckdb";
+  if (cfg.bigquery) dialect = "bigquery";
+  else if (cfg.snowflake) dialect = "snowflake";
+  else if (cfg.duckdb) dialect = "duckdb";
   Object.keys(config).forEach((key) => delete config[key]);
-  Object.assign(config, cfg);
+  Object.assign(config, cfg, { dialect });
 }
 function loadConfig(dir) {
   if (config.root) return;
@@ -147,17 +162,13 @@ function loadConfig(dir) {
   } catch {
     console.warn("No package.json found in current directory");
   }
-  setConfig({
-    ...packageJsonObject,
-    dialect: packageJsonObject.dialect || "duckdb",
-    port: process.env.GRAPHENE_PORT || packageJsonObject.port || 4e3,
-    root: packageJsonObject.root || process.cwd()
-  });
+  setConfig({ ...packageJsonObject, root: packageJsonObject.root || process.cwd() });
 }
 var config;
 var init_config = __esm({
   "../lang/config.ts"() {
-    config = { dialect: "duckdb" };
+    "use strict";
+    config = { dialect: "duckdb", root: "" };
   }
 });
 
@@ -174,6 +185,7 @@ function findOverloads(name, dialect) {
 var globalNamespace, dialectNamespaces, BIGQUERY_DIALECT_FUNCTIONS;
 var init_functions = __esm({
   "../lang/functions.ts"() {
+    "use strict";
     globalNamespace = new GlobalNameSpace();
     dialectNamespaces = /* @__PURE__ */ new Map();
     Object.assign(DUCKDB_DIALECT_FUNCTIONS, {
@@ -303,6 +315,138 @@ var init_functions = __esm({
   }
 });
 
+// ../lang/temporalLiterals.ts
+function parseTemporalLiteral(value, expected) {
+  let raw = (value ?? "").trim();
+  if (!raw) return null;
+  let yearMatch = raw.match(/^([0-9]{4})$/);
+  if (yearMatch) {
+    let year = Number(yearMatch[1]);
+    return buildResult(year, 1, 1, 0, 0, 0, "year", expected);
+  }
+  let yearMonthMatch = raw.match(/^([0-9]{4})-([0-9]{2})$/);
+  if (yearMonthMatch) {
+    let year = Number(yearMonthMatch[1]);
+    let month = Number(yearMonthMatch[2]);
+    if (!inRange(month, 1, 12)) return null;
+    return buildResult(year, month, 1, 0, 0, 0, "month", expected);
+  }
+  let dateMatch = raw.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/);
+  if (dateMatch) {
+    let year = Number(dateMatch[1]);
+    let month = Number(dateMatch[2]);
+    let day = Number(dateMatch[3]);
+    if (!isValidDate(year, month, day)) return null;
+    return buildResult(year, month, day, 0, 0, 0, "day", expected);
+  }
+  if (expected === "timestamp") {
+    let dateTimeMatch = raw.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt\s]([0-9]{1,2})(?::([0-9]{2})(?::([0-9]{2}))?)?$/);
+    if (!dateTimeMatch) return null;
+    let year = Number(dateTimeMatch[1]);
+    let month = Number(dateTimeMatch[2]);
+    let day = Number(dateTimeMatch[3]);
+    if (!isValidDate(year, month, day)) return null;
+    let hour = Number(dateTimeMatch[4]);
+    let minute = dateTimeMatch[5] ? Number(dateTimeMatch[5]) : 0;
+    let second = dateTimeMatch[6] ? Number(dateTimeMatch[6]) : 0;
+    if (!inRange(hour, 0, 23) || !inRange(minute, 0, 59) || !inRange(second, 0, 59)) return null;
+    let timeframe = "hour";
+    if (dateTimeMatch[6]) {
+      timeframe = "second";
+    } else if (dateTimeMatch[5]) {
+      timeframe = "minute";
+    }
+    return buildResult(year, month, day, hour, minute, second, timeframe, expected);
+  }
+  return null;
+}
+function parseTemporal(node) {
+  if (node.node !== "stringLiteral") return null;
+  let rawValue = typeof node.literal === "string" ? node.literal.trim() : "";
+  if (!rawValue) return null;
+  let parsedDate = parseTemporalLiteral(rawValue, "date");
+  if (parsedDate) {
+    let typeDef = { type: parsedDate.type, timeframe: parsedDate.timeframe };
+    Object.assign(node, { node: "timeLiteral", literal: parsedDate.literal, type: parsedDate.type, typeDef });
+    return parsedDate.timeframe;
+  }
+  let parsedTimestamp = parseTemporalLiteral(rawValue, "timestamp");
+  if (parsedTimestamp) {
+    let typeDef = { type: parsedTimestamp.type, timeframe: parsedTimestamp.timeframe };
+    Object.assign(node, { node: "timeLiteral", literal: parsedTimestamp.literal, type: parsedTimestamp.type, typeDef });
+    return parsedTimestamp.timeframe;
+  }
+  let interval = parseIntervalLiteral(rawValue);
+  if (interval) {
+    Object.assign(node, { node: "numberLiteral", literal: interval.quantity.toString(), type: "interval", intervalUnit: interval.unit });
+    return interval.unit;
+  }
+  return null;
+}
+function parseIntervalLiteral(value) {
+  let raw = (value ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+  if (!raw) return null;
+  let match = raw.match(/^(-?\d+(?:\.\d+)?)\s+([a-z]+)$/);
+  if (!match) return null;
+  let quantity = Number(match[1]);
+  if (!Number.isFinite(quantity)) return null;
+  let unit = INTERVAL_UNITS[match[2]];
+  if (!unit) return null;
+  return { quantity, unit };
+}
+function buildResult(year, month, day, hour, minute, second, timeframe, expected) {
+  if (expected === "date") {
+    return { literal: `${pad(year)}-${pad(month)}-${pad(day)}`, timeframe, type: "date" };
+  }
+  return {
+    literal: `${pad(year)}-${pad(month)}-${pad(day)} ${pad(hour)}:${pad(minute)}:${pad(second)}`,
+    timeframe,
+    type: "timestamp"
+  };
+}
+function inRange(value, min, max) {
+  return Number.isInteger(value) && value >= min && value <= max;
+}
+function isValidDate(year, month, day) {
+  if (!inRange(month, 1, 12)) return false;
+  if (!inRange(day, 1, 31)) return false;
+  let date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function pad(value) {
+  return value.toString().padStart(2, "0");
+}
+var INTERVAL_UNITS;
+var init_temporalLiterals = __esm({
+  "../lang/temporalLiterals.ts"() {
+    "use strict";
+    INTERVAL_UNITS = {
+      second: "second",
+      seconds: "second",
+      sec: "second",
+      secs: "second",
+      minute: "minute",
+      minutes: "minute",
+      min: "minute",
+      mins: "minute",
+      hour: "hour",
+      hours: "hour",
+      hr: "hour",
+      hrs: "hour",
+      day: "day",
+      days: "day",
+      week: "week",
+      weeks: "week",
+      month: "month",
+      months: "month",
+      quarter: "quarter",
+      quarters: "quarter",
+      year: "year",
+      years: "year"
+    };
+  }
+});
+
 // ../lang/params.ts
 function inferParamTypes(query) {
   let parentMap = /* @__PURE__ */ new WeakMap();
@@ -409,8 +553,7 @@ function sanitizeType(value) {
   return value;
 }
 function fillInParams(query, params) {
-  let q = structuredClone(query);
-  let filters = q.pipeline[0].filterList || [];
+  let filters = query.pipeline[0].filterList || [];
   for (let filter of filters) {
     walkExpression(filter.e, (e) => {
       if (e.node !== "parameter") return;
@@ -419,20 +562,31 @@ function fillInParams(query, params) {
       else if (value == null) Object.assign(e, { node: "null", type: "string" });
       else if (e.type == "string") Object.assign(e, { node: "stringLiteral", literal: value });
       else if (e.type == "number") Object.assign(e, { node: "numberLiteral", literal: value.toString() });
-      else if (e.type == "boolean") Object.assign(e, { node: value ? "true" : "false" });
+      else if (e.type == "date" || e.type == "timestamp") {
+        if (typeof value !== "string") throw new Error(`Parameters of type ${e.type} must be provided as strings`);
+        let parsed = parseTemporalLiteral(value, e.type);
+        if (!parsed) throw new Error(`Could not parse ${e.type} literal for param $${e.path[0]}`);
+        Object.assign(e, { node: "timeLiteral", literal: parsed.literal, type: parsed.type, typeDef: { type: parsed.type, timeframe: parsed.timeframe } });
+      } else if (e.type == "interval") {
+        if (typeof value !== "string") throw new Error("Parameters of type interval must be provided as strings");
+        let parsed = parseIntervalLiteral(value);
+        if (!parsed) throw new Error(`Could not parse interval literal for param $${e.path[0]}`);
+        Object.assign(e, { node: "numberLiteral", literal: parsed.quantity.toString(), type: "interval", intervalUnit: parsed.unit });
+      } else if (e.type == "boolean") Object.assign(e, { node: value ? "true" : "false" });
       else throw new Error(`Unsupported param type ${e.type}`);
     });
   }
-  return q;
 }
 var COMPARISON_OPS, BOOLEAN_OPS, NUMERIC_UNARY_OPS, FIELD_TYPES;
 var init_params = __esm({
   "../lang/params.ts"() {
+    "use strict";
     init_util();
+    init_temporalLiterals();
     COMPARISON_OPS = /* @__PURE__ */ new Set(["=", "!=", "<>", ">", ">=", "<", "<=", "like", "ilike"]);
     BOOLEAN_OPS = /* @__PURE__ */ new Set(["and", "or"]);
     NUMERIC_UNARY_OPS = /* @__PURE__ */ new Set(["unary-"]);
-    FIELD_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "fieldref", "array", "record", "null"]);
+    FIELD_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "fieldref", "array", "record", "null", "interval"]);
   }
 });
 
@@ -450,34 +604,9 @@ function findTables(fi) {
     }
     let table2 = makeTable(name, syntaxNode.getChild("QueryStatement") ? "query_source" : "table");
     table2.metadata = extractLeadingMetadata(syntaxNode);
-    for (let cn of syntaxNode.getChildren("ColumnDef")) {
-      let name2 = txt(cn.getChild("Identifier"));
-      if (cn.getChild("PrimaryKey")) {
-        if (table2.primaryKey) diag(cn, `Table ${table2.name} has multiple primary keys`);
-        table2.primaryKey = name2;
-      }
-      let type = convertDataType(txt(cn.getChild("DataType")));
-      if (!type) diag(cn, `Unsupported data type: ${txt(cn.getChild("DataType"))}`);
-      let field = { name: name2, type, metadata: extractLeadingMetadata(cn) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, cn);
-    }
-    for (let jn of syntaxNode.getChildren("JoinDef")) {
-      let nameNode = jn.getChild("Alias") || jn.getChild("Identifier");
-      let field = { name: txt(nameNode) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, jn);
-    }
-    for (let cn of syntaxNode.getChildren("ComputedDef")) {
-      let field = { name: txt(cn.getChild("Alias")), metadata: extractLeadingMetadata(cn) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, cn);
-    }
-    table2.fields.reduce((set, f) => {
-      if (!set[f.name]) set[f.name] = true;
-      else diag(FIELD_NODE_MAP.get(f), `Table already has a field called "${f.name}"`);
-      return set;
-    }, {});
+    syntaxNode.getChildren("ColumnDef").forEach((cn) => addColumnField(table2, cn));
+    syntaxNode.getChildren("JoinDef").forEach((jn) => addJoinField(table2, jn));
+    syntaxNode.getChildren("ComputedDef").forEach((cn) => addComputedField(table2, cn));
     TABLE_NODE_MAP.set(table2, syntaxNode);
     fi.tables.push(table2);
   }
@@ -486,12 +615,56 @@ function makeTable(name, type) {
   let tablePath = config.namespace ? `${config.namespace}.${name}` : name;
   return { name, type, fields: [], connection: config.dialect, dialect: config.dialect, tableName: name, tablePath, metadata: {} };
 }
+function addColumnField(table2, node) {
+  let name = txt(node.getChild("Identifier"));
+  if (node.getChild("PrimaryKey")) {
+    if (table2.primaryKey) diag(node, `Table ${table2.name} has multiple primary keys`);
+    table2.primaryKey = name;
+  }
+  let type = convertDataType(txt(node.getChild("DataType")));
+  if (!type) diag(node, `Unsupported data type: ${txt(node.getChild("DataType"))}`);
+  let field = { name, type, metadata: extractLeadingMetadata(node) };
+  return addFieldToTable(table2, field, node);
+}
+function addJoinField(table2, node) {
+  let nameNode = node.getChild("Alias") || node.getChild("Identifier");
+  return addFieldToTable(table2, { name: txt(nameNode) }, node);
+}
+function addComputedField(table2, node) {
+  let name = txt(node.getChild("Alias"));
+  addFieldToTable(table2, { name, metadata: extractLeadingMetadata(node) }, node);
+}
+function addFieldToTable(table2, field, node) {
+  if (table2.fields.find((f) => f.name == field.name)) {
+    diag(node, `Table already has a field called "${field.name}"`);
+    return null;
+  }
+  table2.fields.push(field);
+  FIELD_NODE_MAP.set(field, node);
+  return field;
+}
+function applyExtends(fi) {
+  fi.tree.topNode.getChildren("ExtendStatement").forEach((node) => {
+    let tableName = txt(node.getChild("Identifier"));
+    let target = lookupTable(tableName, node);
+    if (!target) {
+      return diag(node.getChild("Identifier") || node, `Cannot extend unknown table "${tableName}"`);
+    }
+    node.getChildren("JoinDef").forEach((jn) => addJoinField(target, jn));
+    node.getChildren("ComputedDef").forEach((cn) => addComputedField(target, cn));
+  });
+}
 function analyzeTable(table2) {
-  if (table2.type == "query_source") return analyzeQueryTable(table2);
-  for (let f of table2.fields) {
-    if (f.type) continue;
-    analyzeField(f, table2);
+  if (table2.type == "query_source") {
+    if (table2.query) return;
+    let node = TABLE_NODE_MAP.get(table2);
+    let query = analyzeQuery(node.getChild("QueryStatement"));
+    if (!query) return;
+    let queryFields = query.fields.map((f) => ({ type: f.type, name: f.name, metadata: f.metadata }));
+    table2.fields.push(...queryFields);
+    table2.query = query;
   }
+  table2.fields.map((f) => analyzeField(f, table2));
 }
 function analyzeField(field, table2) {
   if (field.type) return;
@@ -504,8 +677,9 @@ function analyzeField(field, table2) {
     field = field;
     let target = lookupTable(txt(node.getChild("Identifier")), node);
     if (!target) return diag(node, "Unknown table to join");
-    if (target.type == "query_source") analyzeQueryTable(target);
-    let jt = { "join_many": "many", "join_one": "one" }[txt(node.getChild("JoinType"))];
+    if (target.type == "query_source") analyzeTable(target);
+    let joinTypeStr = txt(node.getChild("JoinType")).replace(/\s+/g, " ");
+    let jt = { "join many": "many", "join one": "one" }[joinTypeStr];
     if (!jt) return diag(node, "Unknown join type");
     Object.assign(field, target, { name: field.name, join: jt });
     field.onExpression = analyzeExpression(node.getChild("Expression"), { table: table2, outputFields: [] });
@@ -517,37 +691,29 @@ function analyzeField(field, table2) {
   }
   analysisQueue.delete(field);
 }
-function analyzeQueryTable(table2) {
-  if (table2.query) return;
-  let node = TABLE_NODE_MAP.get(table2);
-  let query = analyzeQuery(node.getChild("QueryStatement"));
-  if (!query) throw new Error("Couldnt find query in QueryStatement");
-  table2.fields = query.fields.map((f) => ({ type: f.type, name: f.name, metadata: f.metadata }));
-  table2.query = query.malloyQuery;
-  if (typeof table2.query.structRef == "string") {
-    table2.query.structRef = lookupTable(table2.query.structRef, node);
-  }
-}
 function analyzeQuery(queryNode) {
-  let structRef;
+  let baseTableName;
   let scope = { table: null, outputFields: [] };
   let isAgg = false;
-  let subQuerySources = [];
   if (!txt(queryNode)) return;
+  if (txt(queryNode).trim().toLowerCase() == "select 1") {
+    let fields = [{ name: "col_0", type: "number", metadata: {}, e: { node: "numberLiteral", literal: "1", type: "number" } }];
+    return { fields, baseTableName: "", rawSql: "select 1", structRef: {}, pipeline: [] };
+  }
   let froms = queryNode.getChild("FromClause")?.getChildren("TablePrimary") || [];
   if (froms.find((f) => f.name == "JoinClause")) diag(froms[0], "Query joins not yet supported");
-  if (froms.length == 0) diag(queryNode, "No tables in FROM clause");
+  if (froms.length == 0) return diag(queryNode, "No tables in FROM clause");
   if (froms.length > 1) diag(froms[0], "Multiple tables/joins in FROM clause not yet supported");
   if (froms[0].name == "Subquery") {
-    structRef = txt(froms[0].getChild("Alias")) || "subquery";
-    scope.table = makeTable(structRef, "query_source");
+    diag(froms[0], "Graphene doesn't yet support subqueries. Try chaining queries instead.");
+    baseTableName = txt(froms[0].getChild("Alias")) || "subquery";
+    scope.table = makeTable(baseTableName, "query_source");
     TABLE_NODE_MAP.set(scope.table, froms[0].getChild("SubqueryExpression"));
-    analyzeQueryTable(scope.table);
-    subQuerySources.push(scope.table);
+    analyzeTable(scope.table);
   } else {
-    structRef = txt(froms[0].getChild("Identifier"));
-    scope.table = lookupTable(structRef, froms[0]);
-    if (!scope.table) return diag(froms[0], `could not find table "${structRef}"`);
+    baseTableName = txt(froms[0].getChild("Identifier"));
+    scope.table = lookupTable(baseTableName, froms[0]);
+    if (!scope.table) return diag(froms[0], `could not find table "${baseTableName}"`);
     NODE_ENTITY_MAP.set(froms[0], { entityType: "table", table: scope.table });
   }
   let selects = queryNode.getChild("SelectClause")?.getChildren("SelectItem") || [];
@@ -555,11 +721,12 @@ function analyzeQuery(queryNode) {
   isAgg ||= !!isSelectDistinct;
   selects.forEach((s) => {
     if (s.getChild("Wildcard")) {
-      let path8 = s.getChild("Wildcard").getChildren("Identifier");
-      let pathStrings = path8.map((p) => txt(p));
-      let target = followJoins(path8, scope.table);
+      let path10 = s.getChild("Wildcard").getChildren("Identifier");
+      let pathStrings = path10.map((p) => txt(p));
+      let target = followJoins(path10, scope.table);
       if (!target) return;
       target.fields.forEach((f) => {
+        analyzeField(f, target);
         if (isJoin(f) || f.isAgg) return;
         scope.outputFields.push({ ...f, e: { node: "field", path: [...pathStrings, f.name], type: f.type } });
       });
@@ -613,22 +780,21 @@ function analyzeQuery(queryNode) {
   }
   let q = {
     fields: scope.outputFields,
-    subQuerySources,
-    malloyQuery: {
-      type: "query",
-      structRef,
-      pipeline: [{
-        type: isAgg ? "reduce" : "project",
-        queryFields: scope.outputFields,
-        filterList,
-        outputStruct: null,
-        isRepeated: false,
-        orderBy: orderByList.length ? orderByList : void 0,
-        limit: queryLimit
-      }]
-    }
+    baseTableName,
+    type: "query",
+    structRef: null,
+    // We fill this in as part of `toSql`
+    pipeline: [{
+      type: isAgg ? "reduce" : "project",
+      queryFields: scope.outputFields,
+      filterList,
+      outputStruct: null,
+      isRepeated: false,
+      orderBy: orderByList.length ? orderByList : void 0,
+      limit: queryLimit
+    }]
   };
-  inferParamTypes(q.malloyQuery);
+  inferParamTypes(q);
   return q;
 }
 function analyzeExpression(expr, scope) {
@@ -655,11 +821,13 @@ function analyzeExpression(expr, scope) {
       if (scope.outputFields.includes(field) && field.isAgg) {
         return { node: "outputField", name: field.name, ...typeInfo, isAgg: field.isAgg };
       }
-      let path8 = expr.getChildren("Identifier").map((i) => txt(i));
-      return { node: "field", path: path8, ...typeInfo, isAgg: field.isAgg };
+      let path10 = expr.getChildren("Identifier").map((i) => txt(i));
+      return { node: "field", path: path10, ...typeInfo, isAgg: field.isAgg };
     }
     case "ExtractExpression": {
-      let e = analyzeExpression(expr.getChild("Expression"), scope);
+      let extractExprNode = expr.getChild("Expression");
+      let e = analyzeExpression(extractExprNode, scope);
+      checkTypes(e, ["date", "timestamp"], extractExprNode);
       if (!isTemporalType(e.type) || !e.typeDef) return diag(expr, "Expression must be a date or timestamp", errExpr);
       let units = txt(expr.getChild("ExtractUnit")).replace(/^['"]|['"]$/g, "").toLowerCase();
       if (!isExtractUnit(units)) return diag(expr, "Not a valid unit to extract", errExpr);
@@ -682,7 +850,28 @@ function analyzeExpression(expr, scope) {
       let left2 = analyzeExpression(expr.firstChild, scope);
       let right2 = analyzeExpression(expr.lastChild, scope);
       let op = txt(expr.firstChild?.nextSibling).toLowerCase();
-      return { node: op, kids: { left: left2, right: right2 }, type: left2.type, isAgg: left2.isAgg || right2.isAgg };
+      let type = left2.type;
+      if (op == "or" || op == "and") type = "boolean";
+      if (op == "+" || op == "-") {
+        if (["date", "timestamp", "interval"].find((t) => left2.type == t || right2.type == t)) {
+          return analyzeTimeExpression(op, left2, right2, expr);
+        }
+        ensureSameType(left2, expr.firstChild, right2, expr.lastChild);
+      }
+      if (op == "*" || op == "/" || op == "%") {
+        checkTypes(left2, ["number"], expr.firstChild);
+        checkTypes(right2, ["number"], expr.lastChild);
+      }
+      if (op == "<" || op == "<=" || op == ">" || op == ">=" || op == "=" || op == "!=" || op == "<>") {
+        ensureSameType(left2, expr.firstChild, right2, expr.lastChild);
+        type = "boolean";
+      }
+      if (op == "like" || op == "ilike") {
+        checkTypes(left2, ["string"], expr.firstChild);
+        checkTypes(right2, ["string"], expr.lastChild);
+        type = "boolean";
+      }
+      return { node: op, kids: { left: left2, right: right2 }, type, isAgg: left2.isAgg || right2.isAgg };
     }
     case "NullTestExpression": {
       let node = expr.getChildren("Kw").find((n) => txt(n).toLowerCase() == "not") ? "is-not-null" : "is-null";
@@ -716,8 +905,13 @@ function analyzeExpression(expr, scope) {
       let oneOf = [];
       let valueList = expr.getChild("InValueList");
       if (valueList) {
-        oneOf = valueList.getChildren("Expression").map((v) => analyzeExpression(v, scope));
+        oneOf = valueList.getChildren("Expression").map((v) => {
+          let e = analyzeExpression(v, scope);
+          checkTypes(e, [eNode.type], v);
+          return e;
+        });
       } else {
+        diag(expr, "IN (<subquery>) is not yet supported");
         oneOf = [{ node: "genericSQLExpr", kids: { args: [] }, type: "array" }];
       }
       let isAgg = eNode.isAgg || oneOf.some((v) => v.isAgg);
@@ -735,11 +929,14 @@ function analyzeFunctionCall(expr, scope) {
     return o.params.length == argNodes.length || !!o.params.find((p) => p.isVariadic);
   });
   let args = argNodes.map((node, idx) => {
-    let type2 = overload?.params[idx]?.allowedTypes[0];
-    if (type2?.type === "sql native" && type2?.rawType === "kw") {
+    let firstType = overload?.params[idx]?.allowedTypes[0];
+    if (firstType?.type === "sql native" && firstType?.rawType === "kw") {
       return { node: "genericSQLExpr", kids: { args: [] }, type: "sql native", src: [txt(node)], isAgg: false };
     } else {
-      return analyzeExpression(node, scope);
+      let argExpr = analyzeExpression(node, scope);
+      let allowed = overload?.params[idx]?.allowedTypes.map((at) => at.type);
+      if (allowed) checkTypes(argExpr, allowed, node);
+      return argExpr;
     }
   });
   let type = overload?.returnType.type;
@@ -754,7 +951,12 @@ function analyzeFunctionCall(expr, scope) {
   }));
   let ret;
   if (["count", "min", "max", "avg", "sum"].includes(name.toLowerCase())) {
-    ret = { node: "aggregate", function: name, e: args[0], type: "number", isAgg: true };
+    let type2 = "number", typeDef;
+    if (["min", "max", "avg"].includes(name.toLowerCase())) {
+      type2 = args[0].type;
+      typeDef = args[0].typeDef;
+    }
+    ret = { node: "aggregate", function: name, e: args[0], type: type2, typeDef, isAgg: true };
   } else if (overload && type) {
     ret = {
       node: "function_call",
@@ -775,8 +977,52 @@ function analyzeFunctionCall(expr, scope) {
   if (foriegnPaths.length > 0) ret.structPath = foriegnPaths[0].split(".");
   return ret;
 }
+function analyzeTimeExpression(op, left2, right2, node) {
+  if (left2.type !== "date" && left2.type !== "timestamp") return diag(node, "Expected left side to be a date or timestamp", errExpr);
+  let units = left2.type === "timestamp" ? "second" : "day";
+  if (right2.node == "stringLiteral") {
+    units = parseTemporal(right2);
+    if (right2.node == "stringLiteral") {
+      return diag(node, "Could not parse interval", errExpr);
+    }
+  }
+  if (right2.type == "date" || right2.type == "timestamp") {
+    if (op !== "-") return diag(node, "Only subtraction between dates is supported", errExpr);
+    if (right2.type !== left2.type) return diag(node, `Expected right side to be a ${left2.type}`, errExpr);
+    return { node: "timeDiff", kids: { left: left2, right: right2 }, units, type: "interval", isAgg: false };
+  }
+  if (right2.type == "interval") {
+    let typeDef = { type: left2.type };
+    return { node: "delta", kids: { base: left2, delta: right2 }, op, units, type: left2.type, typeDef, isAgg: false };
+  }
+  return diag(node, "Expected right side to be a date or interval", errExpr);
+}
+function ensureSameType(left2, leftNode, right2, rightNode) {
+  if (left2.type === "error" || right2.type === "error") return;
+  if (left2.node === "parameter" || right2.node === "parameter") return;
+  if (isTemporalType(left2.type)) checkTypes(right2, [left2.type], rightNode);
+  if (isTemporalType(right2.type)) checkTypes(left2, [right2.type], leftNode);
+  if (left2.type !== right2.type) diag(rightNode, `Expected ${left2.type}, got ${right2.type}`);
+}
+function checkTypes(expr, expected, node) {
+  if (expr.type === "error") return;
+  if (expr.node === "parameter") return;
+  if (expected.includes(expr.type)) return;
+  if (expected.includes("generic")) return;
+  let dt = expected.find((t) => t == "date") || expected.find((t) => t == "timestamp");
+  if (expr.node == "stringLiteral" && dt) {
+    let parsed = parseTemporalLiteral(expr.literal, dt);
+    if (!parsed) return diag(node, `Could not parse ${dt} literal: "${expr.literal}"`, void 0);
+    let typeDef = { type: parsed.type, timeframe: parsed.timeframe };
+    Object.assign(expr, { node: "timeLiteral", literal: parsed?.literal, type: parsed?.type, typeDef });
+  } else if (expr.node == "stringLiteral" && expected.includes("interval")) {
+    let parsed = parseIntervalLiteral(expr.literal);
+    if (!parsed) return diag(node, `Could not parse interval literal: "${expr.literal}"`, void 0);
+    return Object.assign(expr, { node: "numberLiteral", literal: parsed.quantity.toString(), type: "interval", intervalUnit: parsed.unit });
+  } else diag(node, `Expected types: ${expected.join(", ")}`);
+}
 function isSupportedType(value) {
-  let supported = ["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "array", "record", "null", "generic"];
+  let supported = ["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "array", "record", "null", "generic", "interval"];
   return supported.includes(value);
 }
 function lookupField(expr, scope) {
@@ -862,6 +1108,10 @@ function convertDataType(dataType) {
       return "number";
     case "INT64":
       return "number";
+    case "NUMBER":
+      return "number";
+    case "VARIANT":
+      return "string";
     case "TEXT":
       return "string";
     case "STRING":
@@ -884,6 +1134,8 @@ function convertDataType(dataType) {
       return "timestamp";
     case "TIMESTAMP":
       return "timestamp";
+    case "TIMESTAMP_NTZ":
+      return "timestamp";
     case "DECIMAL":
       return "number";
     case "DOUBLE":
@@ -907,11 +1159,13 @@ function convertDataType(dataType) {
 var FILE_MAP, diagnostics, TABLE_NODE_MAP, FIELD_NODE_MAP, NODE_ENTITY_MAP, analysisQueue, errExpr;
 var init_analyze = __esm({
   "../lang/analyze.ts"() {
+    "use strict";
     init_util();
     init_metadata();
     init_config();
     init_functions();
     init_params();
+    init_temporalLiterals();
     FILE_MAP = {};
     diagnostics = [];
     TABLE_NODE_MAP = /* @__PURE__ */ new WeakMap();
@@ -923,39 +1177,40 @@ var init_analyze = __esm({
 });
 
 // ../lang/parser.terms.js
-var table, primary_key, as, on, not, exists, from, inner, left, right, full, cross, join, select, where, group, by, order, asc, desc, limit, offset, _in, is, _null, _true, _false, or, and, like;
+var table, primary_key, join, as, on, or, and, like, not, _in, from, inner, left, right, full, cross, select, where, group, by, order, asc, desc, limit, offset, is, _null, exists, _true, _false;
 var init_parser_terms = __esm({
   "../lang/parser.terms.js"() {
+    "use strict";
     table = 6;
     primary_key = 11;
-    as = 19;
-    on = 22;
-    not = 31;
-    exists = 49;
-    from = 53;
-    inner = 59;
-    left = 61;
-    right = 63;
-    full = 65;
-    cross = 67;
-    join = 69;
-    select = 72;
-    where = 80;
-    group = 83;
-    by = 85;
-    order = 91;
-    asc = 95;
-    desc = 97;
-    limit = 100;
-    offset = 102;
-    _in = 105;
+    join = 15;
+    as = 21;
+    on = 24;
+    or = 31;
+    and = 34;
+    like = 43;
+    not = 45;
+    _in = 55;
+    from = 60;
+    inner = 66;
+    left = 68;
+    right = 70;
+    full = 72;
+    cross = 74;
+    select = 77;
+    where = 84;
+    group = 87;
+    by = 89;
+    order = 95;
+    asc = 99;
+    desc = 101;
+    limit = 104;
+    offset = 106;
     is = 109;
     _null = 111;
-    _true = 115;
-    _false = 117;
-    or = 130;
-    and = 132;
-    like = 141;
+    exists = 129;
+    _true = 133;
+    _false = 135;
   }
 });
 
@@ -967,6 +1222,7 @@ function specializeIdentifier(value) {
 var keywords;
 var init_tokens = __esm({
   "../lang/tokens.js"() {
+    "use strict";
     init_parser_terms();
     keywords = {
       select,
@@ -1008,25 +1264,26 @@ import { LRParser } from "@lezer/lr";
 var spec_Identifier, parser;
 var init_parser = __esm({
   "../lang/parser.js"() {
+    "use strict";
     init_tokens();
-    spec_Identifier = { __proto__: null, table: 12, primary_key: 22, join_one: 30, join_many: 34, as: 38, on: 44, not: 62, case: 72, when: 78, then: 82, else: 88, end: 92, exists: 98, from: 106, inner: 118, left: 122, right: 126, full: 130, cross: 134, join: 138, select: 144, distinct: 148, where: 160, group: 166, by: 170, having: 176, order: 182, asc: 190, desc: 194, limit: 200, offset: 204, in: 210, is: 218, null: 222, true: 230, false: 234, count: 244, extract: 250, or: 260, and: 264, like: 282 };
+    spec_Identifier = { __proto__: null, table: 12, primary_key: 22, join: 30, one: 34, many: 38, as: 42, on: 48, or: 62, and: 68, like: 86, not: 90, in: 110, from: 120, inner: 132, left: 136, right: 140, full: 144, cross: 148, select: 154, distinct: 158, where: 168, group: 174, by: 178, having: 184, order: 190, asc: 198, desc: 202, limit: 208, offset: 212, is: 218, null: 222, case: 232, when: 238, then: 242, else: 248, end: 252, exists: 258, true: 266, false: 270, count: 280, extract: 286, extend: 306 };
     parser = LRParser.deserialize({
       version: 14,
-      states: "BbQYQPOOOOQO'#C`'#C`OOQO'#Db'#DbOtQPO'#DaOOQO'#Du'#DuO#QQPO'#DtOOQO'#D}'#D}O#XQPO'#D|OOQO'#EQ'#EQO$YQPO'#EPOOQO'#EV'#EVO#XQPO'#EUOOQO'#EY'#EYO$YQPO'#EXOOQO'#Ec'#EcO$_QPO'#EbOOQO'#Fi'#FiO$dQPO'#D`O$qQPO'#C_O$vQPO'#FeQYQPOOQ%hQPO'#FeO%mQPO'#DdO]QPO'#DfO&zQPO'#DeOOQO'#Fv'#FvO(mQPO,59{O*tQPO'#CtO,^QPO'#CtOOQO'#Cz'#CzOOQO'#Cy'#CyO#XQPO'#CxOOQO'#DP'#DPO,fQPO'#DOOOQO'#D^'#D^O,mQPO'#DfOOQO'#Dw'#DwOOQO'#Dz'#DzO.bQPO'#DyOOQO'#Dy'#DyO/_QPO,5:`O|QPO,5:`O0SQPO'#D]OOQO'#En'#EnOOQO'#Er'#ErOOQO'#Et'#EtOOQO'#Eq'#EqOOQO'#Ev'#EvOOQO'#Fy'#FyOOQO'#Ey'#EyO0XQPO'#ExOOQO'#E|'#E|O0^QPO'#E{OOQO'#Fu'#FuO0cQPO'#CtO0hQPO,5:hOOQO'#ES'#ESO|QPO,5:kO1[QPO,5:pO2OQPO,5:sO2WQPO,5:|OOQO-E9g-E9gO2{QPO,58yOOQO,5<P,5<POOQO-E9c-E9cOOQO'#Cn'#CnOOQO'#Cp'#CpOOQO,5:O,5:OO3TQPO,5:OO3YQPO,5:QOOQO,5:P,5:PO3TQPO,5:POOQO'#Dh'#DhOOQO'#Dj'#DjOOQO'#Dl'#DlOOQO'#Dn'#DnOOQO'#Dp'#DpOOQO'#Dr'#DrOtQPO'#DgO(hQPO'#DgOOQO'#Fj'#FjO3_QPO1G/gOOQO,5<R,5<RO4RQPO,5;kO4YQPO,59`OOQO-E9e-E9eOOQO,5:f,5:fOOQO,59d,59dOOQO'#DS'#DSO#XQPO'#DROOQO'#Fh'#FhO7wQPO,59jO8SQPO,59jO8ZQPO,5;lOOQO,5:e,5:eO3TQPO,5:eOOQO'#Eh'#EhO8bQPO,5;RO8gQPO,5;ROOQO'#El'#ElO8oQPO,5;VOOQO'#FR'#FROOQO'#FT'#FTOOQO'#F^'#F^OOQO'#FV'#FVOOQO'#F`'#F`OOQO'#Fa'#FaO#XQPO,59cO#XQPO,59cO#XQPO,59cO#XQPO,59cO#XQPO,59cO8wQPO1G/zO9kQPO1G/zO9kQPO1G/zO]QPO,59wO:`QPO,5;dO:mQPO,5;gO:uQPO1G0VO;jQPO'#E[O<eQPO1G0_OOQO'#Ee'#EeO=YQPO1G0hO=_QPO1G.eO>fQPO1G1jOOQO1G/j1G/jOOQO1G/l1G/lOOQO1G/k1G/kO>kQPO,5:ROtQPO,5:ROOQO-E9h-E9hO?rQPO1G1VOOQO1G1V1G1VP?|QPO'#FgO@RQPO,59mOOQO-E9f-E9fOOQO'#DX'#DXO#XQPO'#DWOOQO'#DZ'#DZOOQO1G/U1G/UO7}QPO1G/UO7wQPO1G/UOOQO1G1W1G1WOOQO1G0P1G0PO,mQPO1G0mO@YQPO1G0mOOQO,5;q,5;qOOQO1G0q1G0qO8rQPO1G0qOB}QPO1G.}OCUQPO1G.}OExQPO1G.}OFSQPO1G.}OOQO1G.}1G.}OOQO,5<V,5<VOF^QPO7+%fOOQO-E9i-E9iOGQQPO7+%fOGuQPO1G/cOGzQPO1G1OOOQO1G1O1G1OOHRQPO1G1OO#XQPO1G1OOOQO'#FO'#FOOHWQPO1G1ROH]QPO7+%qOIPQPO7+%qOOQO'#E^'#E^OOQO'#E`'#E`OOQO,5:v,5:vOJfQPO7+%yOJpQPO7+%yOOQO7+&S7+&SOJwQPO'#CtOOQO'#Cj'#CjOOQO'#Cl'#ClOOQO'#Ci'#CiOKOQPO'#ChO-WQPOOOL_QPO'#FuOLfQPO'#FuOOQO'#Ft'#FtOLmQPO'#CvOOQO'#Fr'#FrOLrQPO'#FfONPQPO7+$PO]QPO7+'UOOQO'#Cq'#CqO#XQPO1G/mONWQPO1G/mO! _QPO7+&qO! fQPO7+&qOOQO7+&q7+&qOOQO'#DU'#DUO#XQPO1G/XO! nQPO,59rOOQO7+$p7+$pO7}QPO7+$pO! uQPO'#EjO!!PQPO7+&XO,mQPO7+&XOOQO7+&]7+&]P|QPO'#FkO!!UQPO<<IQOOQO7+$}7+$}OOQO7+&j7+&jO!!xQPO7+&jO#XQPO7+&mO!#PQPO<<I]OOQO,5<W,5<WO!#sQPO<<IeOOQO-E9j-E9jOOQO'#Cd'#CdO!$kQPO,58}O!%{QPO,59SO3TQPO,59bOOQO,5<Q,5<QOOQO-E9d-E9dOOQO<<Gk<<GkO!&TQPO<<JpO!&YQPO7+%XO#XQPO7+%XO!'`QPO,5<XOOQO<<J]<<J]O!'jQPO<<J]OOQO-E9k-E9kO!'qQPO7+$sOOQO<<H[<<H[O!(OQPO,5;UO!(VQPO,5;UOOQO<<Is<<IsO!(_QPO<<IsOOQO<<JU<<JUO!(dQPO<<JXP2OQPO'#FlOOQO'#Cf'#CfOOQO'#Ce'#CeOOQO1G.i1G.iO!(kQPO1G.nO3TQPO1G.nOOQO1G.|1G.|OOQOAN@[AN@[O!(pQPO<<HsOOQOAN?wAN?wP#XQPO'#FmO!)vQPO1G0pOOQOAN?_AN?_OOQOAN?sAN?sO!)}QPO'#CtO!+bQPO'#CsOOQO7+$Y7+$YO!&OQPO7+$YO!(kQPO,59_O!(kQPO<<GtOOQO1G.y1G.yOOQOAN=`AN=`",
-      stateData: "!+l~O$dOSPOS~OUPO!VQO!jSO!rUO!uWO!zYO!}[O#W^O~OTfO$egO~OTkOomOpnOqnOtpO!RrO!ouO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O!ltO~P|OTkOomOpnOqnOtpO!RrO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O!w!YO~O#P!^O~O$b!SX$o!SX$k!SX~P]OT!`O~O$o!aOU$XX!V$XX!j$XX!r$XX!u$XX!z$XX!}$XX#W$XX$b$XX~O$o!aO~OT!dOc!cO!V!WX!]!WX!_!WX!a!WX!c!WX!e!WX!g!WX!j!WX!r!WX!u!WX!z!WX!}!WX#W!WX$b!WX$o!WX$k!WXf!WX~OT!dOc!cO!V!XX!]!XX!_!XX!a!XX!c!XX!e!XX!g!XX!j!XX!r!XX!u!XX!z!XX!}!XX#W!XX$b!XX$o!XX$k!XXf!XX~O!]!jO!_!kO!a!lO!c!mO!e!nO!g!oO~O!V!Ta!j!Ta!r!Ta!u!Ta!z!Ta!}!Ta#W!Ta$b!Ta$o!Ta$k!Ta~P(XO$e!uO$g!tOchXihXohXphXqhX!ohX#]hX#ahX#vhX#xhX#zhX#{hX#|hX#}hX$OhX$PhX$RhX$UhX$VhX~OThX!VhX!jhX!rhX!uhX!zhX!}hX#WhX$bhX$lhX$ohXwhX$khXyhX!OhX!]hX!_hX!ahX!chX!ehX!ghX|hX~P)aOT!vO!o!xO~Ow!zO~P#XO!VQO!jSO!rUO!uWO!zYO!}[O#W^O~P#XOi#[OomOp#]Oq#]O!o#^O#]#SO#a#VO#v#XO#x#YO#z#[O#{#[O#|#[O#}#[O$O#[O$P#[O$R#ZO$U#^O$V#^O~OT!dOc!cO!V!mX!j!mX!r!mX!u!mX!z!mX!}!mX#W!mX$b!mX$l!mX$o!mX$k!mX~P-WO$l#dO!V!ha!j!ha!r!ha!u!ha!z!ha!}!ha#W!ha$b!ha$o!ha$k!ha~O$e#gO~O$e#hO~O$e#iO~OT!vO~O!V!pa!j!pa!r!pa!u!pa!z!pa!}!pa#W!pa$b!pa$o!pa$k!pa~P-WO!V!xa!j!xa!r!xa!u!xa!z!xa!}!xa#W!xa$b!xa$o!xa$k!xa~P-WOT#kO#P#kO~O#Y#mO!V#Ua!j#Ua!r#Ua!u#Ua!z#Ua!}#Ua#W#Ua$b#Ua$o#Ua$k#Ua~Oc!cO$e#oO~OT!dO~O$k#rO~O!V!Ti!j!Ti!r!Ti!u!Ti!z!Ti!}!Ti#W!Ti$b!Ti$o!Ti$k!Ti~P(XO$k#xO~P#XO$g!tOThachaihaohaphaqha!Vha!jha!oha!rha!uha!zha!}ha#Wha#]ha#aha#vha#xha#zha#{ha#|ha#}ha$Oha$Pha$Rha$Uha$Vha$bha$lha$ohawha$khayha!Oha!]ha!_ha!aha!cha!eha!gha|ha_haahatha!Rha#Pha#cha#dha#gha#iha#kha#nha#qha$eha~Ow!zO|#|O!O$OO~Ow!zO~P-WO$k$SO~P-WO$e$UO~O#]#SO$R#ZO~OomO#c{O~O!V!hi!j!hi!r!hi!u!hi!z!hi!}!hi#W!hi$b!hi$o!hi$k!hi~P|O$l$aO!V!hi!j!hi!r!hi!u!hi!z!hi!}!hi#W!hi$b!hi$o!hi$k!hi~O!ltO!o$gO$k$fO~P#XOT$iO#d$iO~O$l$kO!V!si!j!si!r!si!u!si!z!si!}!si#W!si$b!si$o!si$k!si~O#R$mO#T$nO!V#OX!j#OX!r#OX!u#OX!z#OX!}#OX#W#OX$b#OX$l#OX$o#OX$k#OX~O$l$pO!V!{i!j!{i!r!{i!u!{i!z!{i!}!{i#W!{i$b!{i$o!{i$k!{i~O#P$rO~OT$sO_$tOa$uOomOpnOqnOtpO!RrO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O$e%QO~Of%RO!V!Za!]!Za!_!Za!a!Za!c!Za!e!Za!g!Za!j!Za!r!Za!u!Za!z!Za!}!Za#W!Za$b!Za$o!Za$k!Za~O$k%WO$l%UO~P-WO$g!tO~Oy%XO~P-WO$e%`O~Oi#[OomOp#]Oq#]O!o#^O#]#SO#z#[O#{#[O#|#[O#}#[O$O#[O$P#[O$R#ZO$U#^O$V#^OTkicki!Vki!jki!rki!uki!zki!}ki#Wki#aki#vki$bki$lki$okiwki$kkiyki!Oki!]ki!_ki!aki!cki!eki!gki|ki~O#x#YO~P@_O#xki~P@_O!o#^O$U#^O$V#^OTkickiikioki!Vki!jki!rki!uki!zki!}ki#Wki#]ki#aki#vki#xki#zki#{ki#|ki#}ki$Oki$Pki$Rki$bki$lki$okiwki$kkiyki!Oki!]ki!_ki!aki!cki!eki!gki|ki~Op#]Oq#]O~PC]Opkiqki~PC]O!V!hq!j!hq!r!hq!u!hq!z!hq!}!hq#W!hq$b!hq$o!hq$k!hq~P|O$l%cO!V!hq!j!hq!r!hq!u!hq!z!hq!}!hq#W!hq$b!hq$o!hq$k!hq~O$k%dO~O$k%eO~P-WO$k%eO~O!VQO~O!V!sq!j!sq!r!sq!u!sq!z!sq!}!sq#W!sq$b!sq$o!sq$k!sq~P|O$l%hO!V!sq!j!sq!r!sq!u!sq!z!sq!}!sq#W!sq$b!sq$o!sq$k!sq~O!V!{q!j!{q!r!{q!u!{q!z!{q!}!{q#W!{q$b!{q$o!{q$k!{q~OT#kO#P#kO~PItO$l%jO~PItOT%lO~P)aOT%nO~Oi$iXo$iXp$iXq$iX!o$iX#]$iX#a$iX#v$iX#x$iX#z$iX#{$iX#|$iX#}$iX$O$iX$P$iX$R$iX$U$iX$V$iX~Oc$hX~PKTOc$nX~PKTOc!cO~O$l%pOT$YX_$YXa$YXo$YXp$YXq$YXt$YX!R$YX#P$YX#c$YX#d$YX#g$YX#i$YX#k$YX#n$YX#q$YX$e$YX$k$YX~O$k%rO~P=_Of%RO!V!Zi!]!Zi!_!Zi!a!Zi!c!Zi!e!Zi!g!Zi!j!Zi!r!Zi!u!Zi!z!Zi!}!Zi#W!Zi$b!Zi$o!Zi$k!Zi~O$k%wO~P#XO$k%wO$l%xO~O!Oza~P-WO$l%|O$k#^X~P-WO$k&OO~O!V!hy!j!hy!r!hy!u!hy!z!hy!}!hy#W!hy$b!hy$o!hy$k!hy~P|O$k&QO~P-WO!V!sy!j!sy!r!sy!u!sy!z!sy!}!sy#W!sy$b!sy$o!sy$k!sy~P|OT#kO#P#kO!V!{y!j!{y!r!{y!u!{y!z!{y!}!{y#W!{y$b!{y$o!{y$k!{y~OZ&TOTVa_VaaVaoVapVaqVatVa!RVa#PVa#cVa#dVa#gVa#iVa#kVa#nVa#qVa$eVa$kVa$lVa~Oc!cOf%RO~O$k&ZO~O!V!Zq!]!Zq!_!Zq!a!Zq!c!Zq!e!Zq!g!Zq!j!Zq!r!Zq!u!Zq!z!Zq!}!Zq#W!Zq$b!Zq$o!Zq$k!Zq~P-WO$k$aa$l$aa~P-WO$k&]O~P#XOwuq|uq!Ouq~P-WO$k#^a~P#XO$l&_O$k#^a~O$k&`O~O$k&aO~P-WOT&bO~O!V!Zy!]!Zy!_!Zy!a!Zy!c!Zy!e!Zy!g!Zy!j!Zy!r!Zy!u!Zy!z!Zy!}!Zy#W!Zy$b!Zy$o!Zy$k!Zy~P-WO$k#^i~P#XO$g!tOihXThX_hXahXohXphXqhXthX!RhX#PhX#chX#dhX#ghX#ihX#khX#nhX#qhX$ehX$khX$lhX~Oi&fO~OP$U!op~",
-      goto: "@[$oPPP$p$tPP$x$|%P%SP$x%V%ZP%ZP%_P%q&ZP&g&mP$x'o'o(j)cPPP'o*tP+m+sP+yP+|,SP,WP'o,bP-Z-o-zP.Y.Y._/]/aP/aP/aP/aP/aP/eP-o/lP/wP/}0`P-o0kP-o0vP1RP-o1XP-o1dP1oP1wP1wP-o1zP2VP'o2YP2r.d2xP3]PP4[5TP5TP4[P5|6wP.d7pP8i5|.d8lP9PP9ePPPPPP9zP:d:zPP$p;c;i;o<q<{=Y=`=n=tPPPP>OP>S>W?}PP5|@WTcOdTbOdT$}#o%PR%m$sR&V%mR&U%mT$w#o%PT$v#o%PQ!ffQ!ihQ#RvQ#p!`Q%o$|R&X%nQ!efQ!hhQ#QvQ#q!fQ#s!iQ$T#RQ&Y%oR&e&XQ%S#tQ%u%TQ&W%nR&g&eQ&d&WR&i&g!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_S$z#o%PS&c&W&gR&h&f!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_T$y#o%P!moTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!lnTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_v#Uv!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$Y#W!mqTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_X!|q!}#O$RX!{q!}#O$RR%Y#zQ$Q!}R%]$RT#}!}$RQ$P!}S%[$Q$RR%{%]!mzTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_SeOdS!ggsQ$d#gQ%_$UQ%s%QR&P%`c`Oadgs#g$U%Q%`bROadgs#g$U%Q%`R%g$jViR!p#uUhR!p#u!m!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_T!rj!sT!qj!sS!pj!sR#u!qcTOadgs#g$U%Q%`QyTR$h#hQxTQ#fyQ#j!Z]$`#d$a$k%b%c%hcwTy!Z#d$a$k%b%c%hcVOadgs#g$U%Q%`cXOadgs#g$U%Q%`Q!ZXR!]]cZOadgs#g$U%Q%`c]Oadgs#g$U%Q%`Q#l!]V%i$p%j&SR$o#kc_Oadgs#g$U%Q%`R#n!^v#Tv!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$V#UQ%_$UR&P%`s#Wv!X![#O#P#w#z$e$x%Z%^%f%t%v%z&R&[!l!PTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_Q$X#WR%a$Y!m!QTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!m!OTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_T$z#o%P!m!STVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!m!UTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_R$j#is#_v!X![#O#P#w#z$e$x%Z%^%f%t%v%z&R&[u#`v!X![#O#P#w#z$Z$e$x%Z%^%f%t%v%z&R&[w#av!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[v#[v!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$W#Uy#bv!X![#O#P#w#z$Z$[$]$e$x%Z%^%f%t%v%z&R&[{#cv!X![#O#P#w#z$Z$[$]$^$e$x%Z%^%f%t%v%z&R&[QdOR!bdQ%P#oR%q%PblTy!Z#d$a$k%b%c%h!`!WVZoqs!u!{#_#`#a#b#c#h#o#}$U$h%P%S%U%Y%`%g%u%x%|&W&^&_&f&gT!wl!WQ!}qS#{!}$RR$R#O`aOdgs#g$U%Q%`R!_aQ!sjR#v!sQ#exU$b#e$c$lQ$c#fR$l#jQ$q#lR%k$qQ%V#wS%y%V%}R%}%^T%O#o%PT$|#o%PbvTy!Z#d$a$k%b%c%hQ!XVQ![ZQ!yoQ#OqQ#PsQ#w!uQ#z!{Q$Z#_Q$[#`Q$]#aQ$^#bQ$_#cQ$e#hS$x#o%PQ%Z#}S%^$U%`Q%f$hQ%t%SY%v%U%x%|&^&_Q%z%YQ&R%gR&[%uQjRQ#t!pR%T#uT${#o%P",
-      nodeNames: "\u26A0 Comment Program TableStatement Kw Identifier table ColumnDef DataType PrimaryKey Kw primary_key JoinDef JoinType Kw join_one Kw join_many Kw as Alias Kw on BinaryExpression Ref = ComputedDef BinaryExpression UnaryExpression UnaryOperator Kw not - + CaseExpression Kw case WhenClause Kw when Kw then ElseClause Kw else Kw end ExistsExpression Kw exists QueryStatement FromClause Kw from TableName Subquery SubqueryExpression JoinClause Kw inner Kw left Kw right Kw full Kw cross Kw join SelectClause Kw select Kw distinct SelectItem Wildcard * WhereClause Kw where GroupByClause Kw group Kw by HavingClause Kw having OrderByClause Kw order OrderItem Number Kw asc Kw desc LimitClause Kw limit Kw offset InExpression Kw in InValueList NullTestExpression Kw is Kw null String Boolean Kw true Kw false Null Param Count Kw count ExtractExpression Kw extract ExtractUnit FunctionCall Parenthetical Kw or Kw and ComparisonOp != <> < > <= >= Kw like AddOp MulOp / % ViewStatement",
-      maxTerm: 169,
+      states: "G`QYQPOOOOQO'#C`'#C`OOQO'#Di'#DiOwQPO'#DhOOQO'#Dz'#DzO#TQPO'#DyOOQO'#ER'#EROOQO'#EU'#EUO#[QPO'#ETOOQO'#EZ'#EZOOQO'#E^'#E^O#[QPO'#E]OOQO'#Eg'#EgO#aQPO'#EfOOQO'#Fp'#FpO#}QPO'#DgO$[QPO'#C_OOQO'#Fj'#FjO$aQPO'#FiO$fQPO'#FlQYQPOOQ%ZQPO'#FlO%`QPO'#EQO%`QPO'#EYO&aQPO'#DkO#fQPO'#DmO'nQPO'#DlOOQO'#GP'#GPO)aQPO,5:SO+hQPO'#CvO-pQPO'#CvOOQO'#DY'#DYO-xQPO'#DmOOQO'#D|'#D|OOQO'#EP'#EPOOQO'#EO'#EOO.cQPO,5:eO!PQPO,5:eO0eQPO'#EOOOQO'#En'#EnOOQO'#Eq'#EqOOQO'#Es'#EsO1_QPO'#ErOOQO'#FQ'#FQO1fQPO'#FPOOQO'#FU'#FUOOQO'#FW'#FWOOQO'#FT'#FTOOQO'#FY'#FYOOQO'#GT'#GTOOQO'#F]'#F]O1kQPO'#F[OOQO'#GS'#GSOOQO'#F`'#F`OOQO'#GR'#GROOQO'#GU'#GUOOQO'#F}'#F}O%`QPO'#EpO1pQPO'#F_OOQO'#EW'#EWO!PQPO,5:oO1uQPO,5:wO1}QPO,5;QOOQO-E9n-E9nO2rQPO,58yO2zQPO,5<TOOQO,5<W,5<WOOQO-E9j-E9jO3PQPO'#CvO3UQPO,5:lO3xQPO,5:tOOQO'#Cp'#CpOOQO'#Cr'#CrOOQO,5:V,5:VO4lQPO,5:VO4qQPO,5:XOOQO,5:W,5:WO4lQPO,5:WOOQO'#Cj'#CjOOQO'#Do'#DoOOQO'#Dq'#DqOOQO'#Ds'#DsOOQO'#Du'#DuOOQO'#Dw'#DwOwQPO'#DnO4vQPO'#DnOOQO'#Fq'#FqO4{QPO1G/nOOQO,5<Y,5<YO5oQPO,5;uO5vQPO,59bOOQO-E9l-E9lOOQO,5:k,5:kO9[QPO,5<OO9cQPO1G0PO:VQPO1G0PO:VQPO1G0POOQO'#Cz'#CzOOQO'#C}'#C}OOQO'#DW'#DWOOQO'#DP'#DPO:zQPO,59}OOQO'#D['#D[OOQO'#D_'#D_OOQO'#Dd'#DdO;SQPO,59}OOQO'#El'#ElO;XQPO,5;VO%`QPO,59hO%`QPO,59hO%`QPO,59hO%`QPO,59hO%`QPO,59hOOQO,5:j,5:jO4lQPO,5:jO;aQPO,5;^OOQO'#Ev'#EvOOQO'#Ft'#FtO;hQPO,5;^O%`QPO'#EuO#fQPO,5;kO;sQPO,5;vOOQO,5;[,5;[O<QQPO,5;yO<YQPO1G0ZO<}QPO'#E`O=xQPO1G0cOOQO'#Ei'#EiO>mQPO1G0lO>rQPO1G.eO?sQPO1G1nO?xQPO1G1oOOQO1G/q1G/qOOQO1G/s1G/sOOQO1G/r1G/rO@yQPO,5:YOwQPO,5:YOOQO-E9o-E9oOBQQPO1G1aOOQO1G1a1G1aPB[QPO'#FnOOQO1G1j1G1jOOQO,5<^,5<^OBaQPO7+%kOOQO-E9p-E9pOCTQPO7+%kOOQO,59k,59kOCxQPO1G/iO-xQPO1G/iOOQO1G0q1G0qO;[QPO1G0qOG]QPO1G/SOGdQPO1G/SOJvQPO1G/SOKQQPO1G/SOOQO1G/S1G/SOOQO1G0U1G0UO;hQPO1G0xOOQO-E9r-E9rOOQO'#E{'#E{OOQO'#E}'#E}OOQO1G0x1G0xO;nQPO1G0xO%`QPO'#EzOK[QPO,5;aOKcQPO1G1VOKhQPO1G1bOOQO1G1b1G1bOKoQPO1G1bO%`QPO1G1bOOQO'#Fb'#FbOKtQPO1G1eOKyQPO7+%uOLmQPO7+%uOOQO'#Eb'#EbOOQO'#Ed'#EdOOQO,5:z,5:zONSQPO7+%}ON^QPO7+%}OOQO7+&W7+&WONeQPO'#CrONoQPO'#CiONwQPO'#ChO/WQPO'#CxOOQO'#F|'#F|OOQO'#Fz'#FzON|QPO'#FmO!!TQPO7+$PO!![QPO'#CxO#fQPO7+'YONhQPO'#CrOOQO'#GW'#GWO!!aQPO'#FuO!#hQPO7+'ZOOQO'#Cs'#CsO%`QPO1G/tO!#oQPO1G/tO!$vQPO7+&{O!%OQPO7+&{OOQO7+&{7+&{P!PQPO'#FrO!%VQPO<<IVO-xQPO7+%TO!%yQPO'#DfO!&TQPO7+%TOOQO7+&]7+&]OOQO7+&d7+&dO;nQPO7+&dO!&YQPO,5;fOOQO'#Ex'#ExO%`QPO1G0{OOQO7+&q7+&qOOQO7+&|7+&|O!&aQPO7+&|O%`QPO7+'PO!&hQPO<<IaOOQO,5<_,5<_O!'[QPO<<IiOOQO-E9q-E9qOOQO'#Cd'#CdO!(SQPO,58}OOQO'#Cl'#ClOOQO'#Cn'#CnOOQO,59T,59TO!)^QPO,59SO:zQPO,5<PO!)fQPO,5<PO;XQPO,5<QO%`QPO,59eO%`QPO,59eO%`QPO,59eO%`QPO,59eO%`QPO,59eO4lQPO,59dOOQO,5<X,5<XOOQO-E9k-E9kOOQO<<Gk<<GkO%`QPO,59dO!)kQPO<<JtOOQO,5<a,5<aOOQO-E9s-E9sOOQO<<Ju<<JuO!)pQPO7+%`O%`QPO7+%`OOQO-E9m-E9mO!*vQPO<<JgOOQO<<Jg<<JgO!*}QPO,5<ZO!+XQPO<<HoO!+^QPO,5:QO!+fQPO,5:QOOQO<<Ho<<HoOOQO<<JO<<JOO!+mQPO7+&gOOQO<<Jh<<JhO!+zQPO<<JkP1uQPO'#FsOOQO'#Cf'#CfOOQO'#Ce'#CeOOQO1G.i1G.iO!,RQPO1G.nO4lQPO1G.nO!,WQPO1G1kO-xQPO1G1kOOQO1G1l1G1lO;[QPO1G1lO!-gQPO1G/PO!-nQPO1G/PO!.|QPO1G/PO!/WQPO1G/POOQO1G/P1G/POOQO1G/O1G/OO!/bQPO1G/OOOQOAN@`AN@`O!0bQPO<<HzP%`QPO'#FoOOQOAN@RAN@ROOQOAN>ZAN>ZO!1hQPO1G/lOOQOAN@VAN@VO!1oQPO'#CvO!2|QPO'#CuOOQO7+$Y7+$YO!)aQPO7+$YO-xQPO7+'VO!3RQPO7+'VOOQO7+'W7+'WO!,RQPO,59aO!,RQPO<<GtO!3WQPO<<JqOOQO<<Jq<<JqOOQO1G.{1G.{OOQOAN=`AN=`OOQOAN@]AN@]",
+      stateData: "!3b~O$lOSPOS~OUPO!^QO!oSO!vUO!yVO#OXO#RYO#[[O$_aO~OThO$miO~OTmO}oO!PxO!QxO!SrO#T!RO#cwO#hyO#u{O#v!RO#y}O#{!OO$Q!SO$T!VO$V!WO$mpO~O!qqO~P!PO!{!]O~O#T!`O~O!^QO!oSO!vUO!yVO#OXO#RYO#[[O~O$j!ZX$y!ZX$t!ZX~P#fOT!bO~OT!cO~O$y!dOU$`X!^$`X!o$`X!v$`X!y$`X#O$`X#R$`X#[$`X$_$`X$j$`X~O$y!dO~OTmO}oO!PxO!QxO#T!RO#cwO#hyO#u{O#v!RO#y}O#{!OO$Q!SO$T!VO$V!WO$mpO~OT!jOe!iO_!_X!^!_X!d!_X!f!_X!h!_X!j!_X!l!_X!o!_X!v!_X!y!_X#O!_X#R!_X#[!_X$j!_X$y!_X$t!_Xh!_X~OT!jOe!iO_!`X!^!`X!d!`X!f!`X!h!`X!j!`X!l!`X!o!`X!v!`X!y!`X#O!`X#R!`X#[!`X$j!`X$y!`X$t!`Xh!`X~O_!pO!d!qO!f!rO!h!sO!j!tO!l!uO~O!^![a!o![a!v![a!y![a#O![a#R![a#[![a$j![a$y![a$t![a~P({O$m!{O$o!zOejXkjXojXrjXtjXujXvjXwjXxjXyjX{jX}jX!PjX!QjX!SjX!TjX!UjX!XjX#ajX~OTjX!^jX!ojX!vjX!yjX#OjX#RjX#[jX$jjX$rjX$yjX$tjX#kjX#mjX#rjX_jX!djX!fjX!hjX!jjX!ljX#pjX#TjX#cjX#hjX#ujX#vjX#yjX#{jX$QjX$TjX$VjX~P*TOT!|O!S#OO~O!^QO!oSO!vUO!yVO#OXO#RYO#[[O~P%`O$r#QO!^!ma!o!ma!v!ma!y!ma#O!ma#R!ma#[!ma$j!ma$y!ma$t!ma~Oe!iOk#WOo#TOr#UOt#WOu#WOv#WOw#WOx#WOy#WO{#VO}oO!P#YO!Q#YO!S#ZO!T#ZO!U#ZO!X#[O#a#^O~OT!jO!^!rX!o!rX!v!rX!y!rX#O!rX#R!rX#[!rX$j!rX$r!rX$y!rX$t!rX~P/WO#k#hO~P%`O$m#lO~O$m#mO~O$m#oO~OT#qO#T#qO~O#^#sO!^#Ya!o#Ya!v#Ya!y#Ya#O#Ya#R#Ya#[#Ya$j#Ya$y#Ya$t#Ya~Oe!iO$m#uO~O$m#wO~OT!|O~O!^!ta!o!ta!v!ta!y!ta#O!ta#R!ta#[!ta$j!ta$y!ta$t!ta~P/ZO!^!|a!o!|a!v!|a!y!|a#O!|a#R!|a#[!|a$j!|a$y!|a$t!|a~P/ZOT!jO~O$t#yO~O_!pO~O!^![i!o![i!v![i!y![i#O![i#R![i#[![i$j![i$y![i$t![i~P({O$t$PO~P%`O$o!zOTjaejakjaojarjatjaujavjawjaxjayja{ja}ja!Pja!Qja!Sja!Tja!Uja!Xja!^ja!oja!vja!yja#Oja#Rja#[ja#aja$jja$rja$yja$tja#kja#mja#rja_ja!dja!fja!hja!jja!lja#pja#Tja#cja#hja#uja#vja#yja#{ja$Qja$Tja$Vja~O$t$RO~P/ZO!^!mi!o!mi!v!mi!y!mi#O!mi#R!mi#[!mi$j!mi$y!mi$t!mi~P!PO$r$TO!^!mi!o!mi!v!mi!y!mi#O!mi#R!mi#[!mi$j!mi$y!mi$t!mi~O{#VO!X#[O~O$m$YO~O}oO#cwO~O#k#hO~P/ZO#k#hO#p$eO#r$fO~O!S$nO!qqO$t$mO~P%`OT$pO#v$pO~O$r$rO!^!wi!o!wi!v!wi!y!wi#O!wi#R!wi#[!wi$j!wi$y!wi$t!wi~O#V$tO#X$uO!^#SX!o#SX!v#SX!y#SX#O#SX#R#SX#[#SX$j#SX$r#SX$y#SX$t#SX~O$r$wO!^#Pi!o#Pi!v#Pi!y#Pi#O#Pi#R#Pi#[#Pi$j#Pi$y#Pi$t#Pi~O#T$yO~OT$zO_!pO}oO!PxO!QxO#T!RO#cwO#hyO#u{O#v!RO#y}O#{!OO$Q!SO$T!VO$V!WO~O$m%TO~OT%UO_!pO}oO!PxO!QxO#T!RO#cwO#hyO#u{O#v!RO#y}O#{!OO$Q!SO$T!VO$V!WO~Oh%YO_!ba!^!ba!d!ba!f!ba!h!ba!j!ba!l!ba!o!ba!v!ba!y!ba#O!ba#R!ba#[!ba$j!ba$y!ba$t!ba~O$r%^O$t%_O~P/ZO$o!zO~O!^!mq!o!mq!v!mq!y!mq#O!mq#R!mq#[!mq$j!mq$y!mq$t!mq~P!PO$r%aO!^!mq!o!mq!v!mq!y!mq#O!mq#R!mq#[!mq$j!mq$y!mq$t!mq~O$m%bO~Ok#WOt#WOu#WOv#WOw#WOx#WOy#WO{#VO}oO!P#YO!Q#YO!S#ZO!T#ZO!U#ZO!X#[O#a#^OTpiepiopi!^pi!opi!vpi!ypi#Opi#Rpi#[pi$jpi$rpi$ypi$tpi#kpi#mpi#rpi_pi!dpi!fpi!hpi!jpi!lpi#ppi#Tpi#cpi#hpi#upi#vpi#ypi#{pi$Qpi$Tpi$Vpi~Or#UO~PC}Orpi~PC}O!S#ZO!T#ZO!U#ZOTpiepikpiopirpitpiupivpiwpixpiypi{pi}pi!Xpi!^pi!opi!vpi!ypi#Opi#Rpi#[pi#api$jpi$rpi$ypi$tpi#kpi#mpi#rpi_pi!dpi!fpi!hpi!jpi!lpi#ppi#Tpi#cpi#hpi#upi#vpi#ypi#{pi$Qpi$Tpi$Vpi~O!P#YO!Q#YO~PGkO!Ppi!Qpi~PGkO#m%iO~P/ZO$t%kO~O$t%lO~P/ZO$t%lO~O!^QO~O!^!wq!o!wq!v!wq!y!wq#O!wq#R!wq#[!wq$j!wq$y!wq$t!wq~P!PO$r%oO!^!wq!o!wq!v!wq!y!wq#O!wq#R!wq#[!wq$j!wq$y!wq$t!wq~O!^#Pq!o#Pq!v#Pq!y#Pq#O#Pq#R#Pq#[#Pq$j#Pq$y#Pq$t#Pq~OT#qO#T#qO~PMbO$r%qO~PMbOT%sO$ZfX~P*TOa%uOc%vO~OT%xO~O$r&SOT$aX_$aX}$aX!P$aX!Q$aX#T$aX#c$aX#h$aX#u$aX#v$aX#y$aX#{$aX$Q$aX$T$aX$V$aX$t$aX~O$t&UO~P>rO$Z&VO~O$r&XOT$iX_$iX}$iX!P$iX!Q$iX#T$iX#c$iX#h$iX#u$iX#v$iX#y$iX#{$iX$Q$iX$T$iX$V$iX$t$iX~O$t&ZO~P?xOh%YO_!bi!^!bi!d!bi!f!bi!h!bi!j!bi!l!bi!o!bi!v!bi!y!bi#O!bi#R!bi#[!bi$j!bi$y!bi$t!bi~O$r&_O$t&`O~O$t&`O~P%`O!^!my!o!my!v!my!y!my#O!my#R!my#[!my$j!my$y!my$t!my~P!PO$r&dO$t!YX~P/ZO$t&eO~O#r#na~P/ZO$t&hO~P/ZO!^!wy!o!wy!v!wy!y!wy#O!wy#R!wy#[!wy$j!wy$y!wy$t!wy~P!POT#qO#T#qO!^#Py!o#Py!v#Py!y#Py#O#Py#R#Py#[#Py$j#Py$y#Py$t#Py~OZ&kOTVa_Va}Va!PVa!QVa#TVa#cVa#hVa#uVa#vVa#yVa#{Va$QVa$TVa$VVa$rVa$tVa~Oe!iOh%YO~O$m&qO~O$t&{O~O_!bq!^!bq!d!bq!f!bq!h!bq!j!bq!l!bq!o!bq!v!bq!y!bq#O!bq#R!bq#[!bq$j!bq$y!bq$t!bq~P/ZO$t'OO~P%`O$r$ca$t$ca~P/ZO$t'PO~O$r'QO$t!Ya~O$t!Ya~P%`O#k#iq#p#iq#r#iq~P/ZO$t'RO~P/ZOT'SO~O$m'WO~Ok#WOt#WOu#WOv#WOw#WOx#WOy#WO{#VO}oO!P#YO!Q#YO!S#ZO!T#ZO!U#ZO!X#[O#a#^Oemiomi~Or#UO~P!,]Ormi~P!,]O!S#ZO!T#ZO!U#ZOemikmiomirmitmiumivmiwmixmiymi{mi}mi!Xmi#ami~O!P#YO!Q#YO~P!-uO!Pmi!Qmi~P!-uOTli_li#Tli#cli#hli#uli#vli#yli#{li$Qli$Tli$Vli$rli$tli~P/ZO_!by!^!by!d!by!f!by!h!by!j!by!l!by!o!by!v!by!y!by#O!by#R!by#[!by$j!by$y!by$t!by~P/ZO$t!Yi~P%`O$o!zOkjXTjX_jX}jX!PjX!QjX#TjX#cjX#hjX#ujX#vjX#yjX#{jX$QjX$TjX$VjX$rjX$tjX~Ok'ZO~O$t'^O~O$t'aO~OP!T!S!Q~",
+      goto: "Hi${PPP$|%QPP%U%Y%]%`P%c%k%qP&OP&OP&RP&e'TP'a'gP%c(q(wP)_*^P*vPPPPPP+bP,OP-sPP.aPPP)_/PP/q/}0i0vP1W1W1]2a2eP2eP2eP2eP2eP0i2iP2vP2|3_0i3jP0i3wP4UP0i4[P0i4iP4vP5OP5OP0i5RP5`P)_5cP5}P7^8a7^9dP:g:mP:sP:v:|P;QP7^;[PP<_=bP=bP<_>e>e?hP7^@kPAnP1b(q(qP$|$|AqPAuA{BRC_CiCxDOD^DdDnPPPPDtPDxEOPGVPG`7^>e)_PHeTcOdT`OdT%P#u%RR%t$zR&m%tR&l%tS%P#u%RT%V#w%XX$|#u#w%R%XS!vl!yQ#|!wX${#u#w%R%XR%w${Q!lhQ!ojQ#fvQ#v!bQ&R$}R&o%xQ!khQ!njQ#evQ#x!lQ#z!oQ$b#fW%S#u#w%R%XQ&y&RR'V&oQ%Z#{Q&]%[Q&n%xR'['VQ'U&nR'`'[#Q!UTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WS'T&n'[R'_'ZX%O#u#w%R%Xr#`v!g!h#P#g$O$j$l%c%h%m&[&a&g&i&z&|R%|$}!y!YTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m$T$Y$i$o$r%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'Wv#av!g!h#P#g$O$]$j$l%c%h%m&[&a&g&i&t&z&|R%}$}z#bv!g!h#P#g$O$]$^$j$l%c%h%m&[&a&g&i&t&u&z&|R&O$}|#Wv!g!h#P#g$O$]$^$j$l$}%c%h%m&[&a&g&i&t&u&z&|T$W#X%y#QxTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'Wz#Xv!g!h#P#g$O$]$^$j$l%c%h%m&[&a&g&i&t&u&z&|Q$[#_Q%y$}R&s%{!O#cv!g!h#P#g$O$]$^$_$j$l%c%h%m&[&a&g&i&t&u&v&z&|R&P$}!S#dv!g!h#P#g$O$]$^$_$`$j$l%c%h%m&[&a&g&i&t&u&v&w&z&|R&Q$}z#]v!g!h#P#g$O$]$^$j$l%c%h%m&[&a&g&i&t&u&z&|Q$X#XQ%z$}R&p%yQ%d$YQ&b%bQ'X&qR']'WSeOdS!mipQ$k#lQ%d$YQ&W%TQ&b%bQ'X&qR']'Wg^O_dip#l$Y%T%b&q'WfRO_dip#l$Y%T%b&q'WR%n$qVkR!v#|UjR!v#|!y!XTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m$T$Y$i$o$r%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WT!xl!yT!wl!ygTO_dip#l$Y%T%b&q'WQuTR$o#mQtTQ#SuQ#p!^]$S#Q$T$r%`%a%ocsTu!^#Q$T$r%`%a%ogfO_dip#l$Y%T%b&q'WgWO_dip#l$Y%T%b&q'WQ!^WR!_ZggO_dip#l$Y%T%b&q'WgZO_dip#l$Y%T%b&q'WQ#r!_V%p$w%q&jR$v#qg]O_dip#l$Y%T%b&q'WR#t!`z#_v!g!h#P#g$O$]$^$j$l%c%h%m&[&a&g&i&t&u&z&|R%{$}#Q!QTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WQ$Z#_Q%e$[Q&r%{R'Y&s#R!WTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R!ZTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#RzTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WX#iz#g#j$cX#kz#g#j$cR%j$jQ$h#jR%g$cT$i#j$cQ$g#jS%f$c$hR&f%g#R|Tfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R!RTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R!PTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R!UTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R!TTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'W#R![Tfgpuz!Z!^!{#Q#`#a#b#c#d#k#m#u#w$T$Y$i$o$r%R%X%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WR$q#oTbOdQdOR!edQ%R#uR&T%RbnTu!^#Q$T$r%`%a%o!t!ffgpz!Z!{#`#a#b#c#d#k#m#u#w$Y$i$o%R%X%Z%^%b%j%n%|%}&O&P&Q&V&]&_&d&n&q&}'Q'W'Z'[T!}n!fQ%]$OS&^%]&cR&c%cd_Odip#l$Y%T%b&q'WR!a_Q!ylR#}!yQ#RtU$U#R$V$sQ$V#SR$s#pQ$x#rR%r$xQ#jzQ$c#gT$d#j$cQ%X#wR&Y%XT%Q#u%RX$}#u#w%R%XbvTu!^#Q$T$r%`%a%oQ!gfQ!hgQ#PpQ#gzQ#n!ZQ$O!{Q$]#`Q$^#aQ$_#bQ$`#cQ$a#dQ$j#kQ$l#mW%c$Y%b&q'WQ%h$iQ%m$oQ&[%ZY&a%^&_&d&}'QQ&g%jQ&i%nQ&t%|Q&u%}Q&v&OQ&w&PQ&x&QQ&z&VR&|&]QlRQ#{!vR%[#|!x!YTfgpuz!Z!^!{#Q#`#a#b#c#d#k#m$T$Y$i$o$r%Z%^%`%a%b%j%n%o%|%}&O&P&Q&V&]&_&d&q&}'Q'WX%O#u#w%R%XT%W#w%X",
+      nodeNames: "\u26A0 Comment Program TableStatement Kw Identifier table ColumnDef DataType PrimaryKey Kw primary_key JoinDef JoinType Kw join Kw one Kw many Kw as Alias Kw on BinaryExpression Ref = ComputedDef BinaryExpression Kw or BinaryExpression Kw and ComparisonOp != <> < > <= >= Kw like Kw not AddOp + - MulOp * / % InExpression Kw in InValueList QueryStatement FromClause Kw from TableName Subquery SubqueryExpression JoinClause Kw inner Kw left Kw right Kw full Kw cross SelectClause Kw select Kw distinct SelectItem Wildcard WhereClause Kw where GroupByClause Kw group Kw by HavingClause Kw having OrderByClause Kw order OrderItem Number Kw asc Kw desc LimitClause Kw limit Kw offset NullTestExpression Kw is Kw null UnaryExpression UnaryOperator CaseExpression Kw case WhenClause Kw when Kw then ElseClause Kw else Kw end ExistsExpression Kw exists String Boolean Kw true Kw false Null FunctionCall Count Kw count ExtractExpression Kw extract ExtractUnit Param Parenthetical InExpression NullTestExpression : ViewStatement ExtendStatement Kw extend",
+      maxTerm: 180,
       nodeProps: [
-        ["group", -6, 23, 56, 107, 119, 123, 128, "Expression", -12, 24, 27, 28, 34, 47, 93, 103, 112, 113, 118, 120, 127, "Expression Expression", -2, 54, 55, "TablePrimary"]
+        ["group", -9, 25, 29, 32, 53, 63, 107, 146, 147, 148, "Expression", -12, 26, 97, 112, 114, 127, 130, 131, 136, 137, 138, 141, 145, "Expression Expression", -2, 61, 62, "TablePrimary"]
       ],
       skippedNodes: [0, 1],
-      repeatNodeCount: 9,
-      tokenData: "*g~RnX^#Ppq#Pqr#trs$Ptu$nuv%`wx%exy%}yz&Sz{&X{|&^|}&c}!O&h!O!P'X!P!Q'^!Q![(m!]!^)W!^!_)]!_!`)r!`!a)w!c!}*U#T#o*U#y#z#P$f$g#P#BY#BZ#P$IS$I_#P$I|$JO#P$JT$JU#P$KV$KW#P&FU&FV#P~#UY$d~X^#Ppq#P#y#z#P$f$g#P#BY#BZ#P$IS$I_#P$I|$JO#P$JT$JU#P$KV$KW#P&FU&FV#P~#wP!_!`#z~$PO#z~~$STOr$Prs$cs;'S$P;'S;=`$h<%lO$P~$hO#d~~$kP;=`<%l$P~$qS!Q![$}!c!}$}#R#S$}#T#o$}~%SS#k~!Q![$}!c!}$}#R#S$}#T#o$}~%eO$V~~%hTOw%ewx$cx;'S%e;'S;=`%w<%lO%e~%zP;=`<%l%e~&SO$e~~&XO$k~~&^O!o~~&cOq~~&hO$l~~&mPp~}!O&p~&uSP~OY&pZ;'S&p;'S;=`'R<%lO&p~'UP;=`<%l&p~'^O$g~~'cP$U~z{'f~'iTOz'fz{'x{;'S'f;'S;=`(g<%lO'f~'{VOz'fz{'x{!P'f!P!Q(b!Q;'S'f;'S;=`(g<%lO'f~(gOP~~(jP;=`<%l'f~(rQ#P~!O!P(x!Q![(m~({P!Q![)O~)TP#P~!Q![)O~)]O$o~~)bQ#|~!_!`)h!`!a)m~)mO$O~~)rO#{~~)wOi~~)|P#}~!_!`*P~*UO$P~~*ZST~!Q![*U!c!}*U#R#S*U#T#o*U",
+      repeatNodeCount: 10,
+      tokenData: "*o~RoX^#Spq#Sqr#wrs$Stu$quv%cwx%hxy&Qyz&Vz{&[{|&a|}&f}!O&k!O!P'[!P!Q'a!Q![(p![!])Z!]!^)`!^!_)e!_!`)z!`!a*P!c!}*^#T#o*^#y#z#S$f$g#S#BY#BZ#S$IS$I_#S$I|$JO#S$JT$JU#S$KV$KW#S&FU&FV#S~#XY$l~X^#Spq#S#y#z#S$f$g#S#BY#BZ#S$IS$I_#S$I|$JO#S$JT$JU#S$KV$KW#S&FU&FV#S~#zP!_!`#}~$SOt~~$VTOr$Srs$fs;'S$S;'S;=`$k<%lO$S~$kO#v~~$nP;=`<%l$S~$tS!Q![%Q!c!}%Q#R#S%Q#T#o%Q~%VS$V~!Q![%Q!c!}%Q#R#S%Q#T#o%Q~%hO!U~~%kTOw%hwx$fx;'S%h;'S;=`%z<%lO%h~%}P;=`<%l%h~&VO$m~~&[O$t~~&aO!S~~&fO!P~~&kO$r~~&pP!Q~}!O&s~&xSP~OY&sZ;'S&s;'S;=`'U<%lO&s~'XP;=`<%l&s~'aO$o~~'fP!T~z{'i~'lTOz'iz{'{{;'S'i;'S;=`(j<%lO'i~(OVOz'iz{'{{!P'i!P!Q(e!Q;'S'i;'S;=`(j<%lO'i~(jOP~~(mP;=`<%l'i~(uQ#T~!O!P({!Q![(p~)OP!Q![)R~)WP#T~!Q![)R~)`O$Z~~)eO$y~~)jQv~!_!`)p!`!a)u~)uOx~~)zOu~~*POk~~*UPw~!_!`*X~*^Oy~~*cST~!Q![*^!c!}*^#R#S*^#T#o*^",
       tokenizers: [0],
       topRules: { "Program": [0, 2] },
       specialized: [{ term: 5, get: (value, stack) => specializeIdentifier(value, stack) << 1, external: specializeIdentifier }, { term: 5, get: (value) => spec_Identifier[value] || -1 }],
-      tokenPrec: 2599
+      tokenPrec: 2957
     });
   }
 });
@@ -1189,6 +1446,7 @@ function isFence(event) {
 var COMPONENT_ATTRIBUTE_KEYS, GSQL_FENCE, COMPONENT_TAG, ATTRIBUTE;
 var init_markdown = __esm({
   "../lang/markdown.ts"() {
+    "use strict";
     init_parser();
     COMPONENT_ATTRIBUTE_KEYS = ["x", "y", "y2", "series", "value", "category"];
     GSQL_FENCE = /^([ \t]*)(`{3,})g?sql[^\n]*\n([\s\S]*?)^\1\2[ \t]*$/gim;
@@ -1197,6 +1455,74 @@ var init_markdown = __esm({
   }
 });
 
+// ../lang/snowflake.ts
+function uppercaseMalloyQuery(query) {
+  query.baseTableName = uppercaseIdentifier(query.baseTableName);
+  for (let stage of query.pipeline || []) {
+    let fields = stage.queryFields || [];
+    fields.forEach((field) => uppercaseColumnField(field));
+    let filters = stage.filterList || [];
+    filters.forEach((filter) => uppercaseExpression(filter?.e));
+  }
+}
+function uppercaseTable(table2) {
+  if (table2.upperCased) return;
+  table2.upperCased = true;
+  table2.name = uppercaseIdentifier(table2.name);
+  if (table2.primaryKey) table2.primaryKey = uppercaseIdentifier(table2.primaryKey);
+  if (table2.tableName) table2.tableName = uppercaseQualified(table2.tableName);
+  if (table2.tablePath) table2.tablePath = uppercaseQualified(table2.tablePath);
+  table2.fields?.forEach((field) => uppercaseField(field));
+  if (table2.query) uppercaseMalloyQuery(table2.query);
+}
+function uppercaseField(field) {
+  if (!field) return;
+  if (isJoinField(field)) {
+    field.name = uppercaseIdentifier(field.name);
+    if (field.tableName) field.tableName = uppercaseQualified(field.tableName);
+    if (field.tablePath) field.tablePath = uppercaseQualified(field.tablePath);
+    if (field.structPath) field.structPath = field.structPath.map(uppercaseIdentifier);
+    if (field.path) field.path = field.path.map(uppercaseIdentifier);
+    if (field.onExpression) uppercaseExpression(field.onExpression);
+    uppercaseTable(field);
+  } else {
+    uppercaseColumnField(field);
+  }
+}
+function uppercaseColumnField(field) {
+  if (!field) return;
+  field.name = uppercaseIdentifier(field.name);
+  if (field.path) field.path = field.path.map(uppercaseIdentifier);
+  if (field.structPath) field.structPath = field.structPath.map(uppercaseIdentifier);
+  if (field.tableName) field.tableName = uppercaseQualified(field.tableName);
+  if (field.tablePath) field.tablePath = uppercaseQualified(field.tablePath);
+  if (field.e) uppercaseExpression(field.e);
+}
+function uppercaseExpression(expr) {
+  if (!expr) return;
+  walkExpression(expr, (node) => {
+    if (Array.isArray(node.path)) node.path = node.path.map(uppercaseIdentifier);
+    if (Array.isArray(node.structPath)) node.structPath = node.structPath.map(uppercaseIdentifier);
+  });
+}
+function uppercaseIdentifier(value) {
+  if (!value) return value || "";
+  return value.toString().toUpperCase();
+}
+function uppercaseQualified(value) {
+  if (!value) return value;
+  return value.split(".").map((part) => part.startsWith('"') && part.endsWith('"') ? part : uppercaseIdentifier(part)).join(".");
+}
+function isJoinField(field) {
+  return !!field?.join;
+}
+var init_snowflake = __esm({
+  "../lang/snowflake.ts"() {
+    "use strict";
+    init_util();
+  }
+});
+
 // ../lang/core.ts
 import { registerDialect, StandardSQLDialect, QueryModel, expandBlueprintMap } from "@graphenedata/malloy";
 import { readFile } from "node:fs/promises";
@@ -1211,15 +1537,19 @@ function getDiagnostics() {
 async function loadWorkspace(dir, includeMd) {
   let files = await glob(includeMd ? "**/*.{gsql,md}" : "**/*.gsql", { cwd: dir, ignore: ["node_modules/**"] });
   for await (let file of files) {
-    let contents = await readFile(path2.join(dir, file), "utf-8");
-    updateFile(contents, file);
+    try {
+      let contents = await readFile(path2.join(dir, file), "utf-8");
+      updateFile(contents, file);
+    } catch (e) {
+      console.error("Failed to read file", file, e.message);
+    }
   }
 }
-function updateFile(contents, path8) {
-  FILE_MAP[path8] ||= { path: path8, contents, tree: null, tables: [], queries: [] };
-  FILE_MAP[path8].contents = contents;
-  FILE_MAP[path8].tree = null;
-  return FILE_MAP[path8];
+function updateFile(contents, path10) {
+  FILE_MAP[path10] ||= { path: path10, contents, tree: null, tables: [], queries: [] };
+  FILE_MAP[path10].contents = contents;
+  FILE_MAP[path10].tree = null;
+  return FILE_MAP[path10];
 }
 function analyze(contents, type) {
   clearDiagnostics();
@@ -1232,6 +1562,7 @@ function analyze(contents, type) {
     recordSyntaxErrors(fi);
     findTables(fi);
   });
+  Object.values(FILE_MAP).forEach(applyExtends);
   Object.values(FILE_MAP).flatMap((f) => f.tables).forEach(analyzeTable);
   if (contents) {
     let fi = FILE_MAP["input"];
@@ -1243,12 +1574,22 @@ function analyze(contents, type) {
   }
 }
 function toSql(query, params = {}) {
-  let contents = {};
-  let gsqlTables = Object.values(FILE_MAP).filter((f) => f.path !== "input").flatMap((f) => f.tables);
-  gsqlTables.forEach((t) => contents[t.name] = t);
-  let inputTables = [...FILE_MAP["input"]?.tables || [], ...query.subQuerySources];
-  inputTables.forEach((t) => contents[t.name] = { ...t, query: t.query && fillInParams(t.query, params) });
-  let malloyQuery = fillInParams(query.malloyQuery, params);
+  if (query.rawSql) return query.rawSql;
+  let contents = Object.fromEntries(Object.values(FILE_MAP).flatMap((fi) => {
+    return fi.tables.map((t) => {
+      t = structuredClone(t);
+      if (fi.path == "input" && t.query) fillInParams(t.query, params);
+      if (config.dialect == "snowflake") uppercaseTable(t);
+      return [t.name, t];
+    });
+  }));
+  query = structuredClone(query);
+  fillInParams(query, params);
+  if (config.dialect == "snowflake") uppercaseMalloyQuery(query);
+  let tableQueries = Object.values(contents).map((t) => t.query);
+  let joinQueries = Object.values(contents).flatMap((t) => t.fields.map((f) => f.query));
+  let allQueries = [...tableQueries, ...joinQueries, query].filter((q) => !!q);
+  allQueries.forEach((q) => q.structRef = contents[q.baseTableName]);
   let qm = new QueryModel({
     name: "generated_model",
     contents,
@@ -1256,11 +1597,12 @@ function toSql(query, params = {}) {
     dependencies: {},
     exports: []
   });
-  return qm.compileQuery(malloyQuery).sql;
+  return qm.compileQuery(query).sql;
 }
 var BigQueryDialect;
 var init_core = __esm({
   "../lang/core.ts"() {
+    "use strict";
     init_analyze();
     init_params();
     init_util();
@@ -1268,6 +1610,7 @@ var init_core = __esm({
     init_functions();
     init_parser();
     init_markdown();
+    init_snowflake();
     BigQueryDialect = class extends StandardSQLDialect {
       constructor() {
         super();
@@ -1281,6 +1624,543 @@ var init_core = __esm({
   }
 });
 
+// printer.ts
+import { styleText as nodeStyleText } from "node:util";
+import Table from "cli-table3";
+import chalk from "chalk";
+function offsetToLineCol(src, offset2) {
+  let lines = src.split(/\r?\n/);
+  let acc = 0;
+  for (let i = 0; i < lines.length; i++) {
+    let lineText = lines[i];
+    let nextAcc = acc + lineText.length + 1;
+    if (offset2 < nextAcc || i === lines.length - 1) {
+      let col = Math.max(0, offset2 - acc);
+      return { line: i + 1, col, lineStart: acc, lineText };
+    }
+    acc = nextAcc;
+  }
+  return { line: 1, col: 0, lineStart: 0, lineText: lines[0] || "" };
+}
+function printDiagnostics(diags, log) {
+  log ||= console.log;
+  let parts = [];
+  for (let d of diags) {
+    let src = getFile2(d.file)?.contents || "";
+    let { line, col, lineStart, lineText } = offsetToLineCol(src, d.from.offset);
+    let endCol = Math.max(col + 1, Math.min(lineText.length, d.to.offset - lineStart));
+    let caretLen = Math.max(1, endCol - col);
+    let sev = d.severity === "error" ? "red" : "yellow";
+    let header = `${styleText(sev, d.severity.toUpperCase())}: ${d.file} line ${line}: ${d.message}`;
+    let gutter = "   | ";
+    let caretLine = `${" ".repeat(col)}${styleText(sev, "^".repeat(caretLen))}`;
+    parts.push([header, `${gutter}${lineText}`, `${gutter}${caretLine}`].join("\n"));
+  }
+  if (parts.length) log(parts.join("\n"));
+}
+function printTable(rows) {
+  if (!rows || rows.length === 0) {
+    console.log(chalk.yellow("No results returned"));
+    return;
+  }
+  let headers = Object.keys(rows[0]);
+  let table2 = new Table({ head: headers.map((h) => chalk.blue(h)) });
+  let MAX_DISPLAY_ROWS = 200;
+  let displayRows = rows.slice(0, MAX_DISPLAY_ROWS);
+  displayRows.forEach((row) => table2.push(headers.map((h) => row[h]?.toString() || "")));
+  console.log(table2.toString());
+  if (rows.length > MAX_DISPLAY_ROWS) {
+    console.log(chalk.yellow(`Displayed first ${MAX_DISPLAY_ROWS} rows (of ${rows.length} total).`));
+  }
+}
+var styleText;
+var init_printer = __esm({
+  "printer.ts"() {
+    "use strict";
+    init_core();
+    styleText = (style, text) => {
+      try {
+        return nodeStyleText ? nodeStyleText(style, text) : text;
+      } catch {
+        return text;
+      }
+    };
+  }
+});
+
+// background.ts
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+import { fileURLToPath } from "url";
+import fs2 from "fs-extra";
+import path3 from "path";
+async function runServeInBackground() {
+  let grapheneCache = getGrapheneCache(config.root);
+  let logFile = path3.join(grapheneCache, "serve.log");
+  await fs2.ensureDir(grapheneCache);
+  let log = fs2.openSync(logFile, "w");
+  let entryPoint = process.argv[1] || fileURLToPath(import.meta.url);
+  let childArgs = [...process.execArgv, entryPoint, "serve"];
+  let child = spawn(process.execPath, childArgs, {
+    cwd: config.root,
+    detached: true,
+    env: { ...process.env },
+    stdio: ["ignore", log, log]
+  });
+  if (!child.pid) throw new Error("Failed to start server process");
+  await new Promise((resolve, reject) => {
+    let buffer = "";
+    fs2.watchFile(logFile, { interval: 200 }, (curr, prev) => {
+      if (curr.size > prev.size) {
+        let stream = fs2.createReadStream(logFile, { start: 0, end: curr.size - 1 });
+        stream.on("data", (d) => {
+          process.stdout.write(d);
+          buffer = (buffer + d.toString()).slice(-200);
+          if (buffer.includes("Server running at http://localhost:")) resolve();
+        });
+      }
+    });
+    child.once("exit", () => {
+      reject(new Error("Exited before server started"));
+    });
+    child.once("error", (e) => reject(e));
+  });
+}
+function getGrapheneCache(root) {
+  return path3.join(root, "node_modules", ".graphene");
+}
+function sendSignal(pid, signal) {
+  let pids = process.platform === "win32" ? [pid] : [pid, -pid];
+  for (let target of pids) {
+    try {
+      process.kill(target, signal);
+    } catch (err) {
+      let code = err.code;
+      if (code === "ESRCH" || code === "EINVAL") continue;
+      return false;
+    }
+  }
+  return true;
+}
+async function stopGrapheneIfRunning() {
+  let port = Number(process.env.GRAPHENE_PORT) || 4e3;
+  let pid = await getPidOnPort(port);
+  if (!pid) return;
+  console.log(`Stopping server (${pid})`);
+  sendSignal(pid, "SIGTERM");
+  let end = Date.now() + 5e3;
+  while (Date.now() < end) {
+    if (!await getPidOnPort(port)) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (await getPidOnPort(port)) {
+    sendSignal(pid, "SIGKILL");
+  }
+  if (await getPidOnPort(port)) {
+    console.error("Failed to stop previous Graphene server");
+  }
+}
+async function isServerRunning(portOverride) {
+  let port = portOverride || Number(process.env.GRAPHENE_PORT) || 4e3;
+  return !!await getPidOnPort(port);
+}
+async function getPidOnPort(port) {
+  try {
+    if (process.platform === "win32") {
+      let { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
+      let lines = stdout.trim().split("\n");
+      for (let line of lines) {
+        let parts = line.trim().split(/\s+/);
+        if (parts.length < 5) continue;
+        let localAddress = parts[1];
+        let pid = parseInt(parts[parts.length - 1], 10);
+        if (localAddress.endsWith(`:${port}`)) {
+          return pid;
+        }
+      }
+    } else {
+      return new Promise((resolve) => {
+        let child = spawn("lsof", ["-i", `:${port}`, "-t", "-sTCP:LISTEN"]);
+        let stdout = "";
+        child.stdout.on("data", (d) => stdout += d.toString());
+        child.on("close", (code) => {
+          if (code !== 0) return resolve(void 0);
+          let pid = parseInt(stdout.trim(), 10);
+          resolve(isNaN(pid) ? void 0 : pid);
+        });
+        child.on("error", () => resolve(void 0));
+      });
+    }
+  } catch (e) {
+    console.warn("Failed to check for server:", e.message);
+    return void 0;
+  }
+  return void 0;
+}
+var execAsync;
+var init_background = __esm({
+  "background.ts"() {
+    "use strict";
+    init_config();
+    execAsync = promisify(exec);
+  }
+});
+
+// mockFiles.ts
+var mockFileMap;
+var init_mockFiles = __esm({
+  "mockFiles.ts"() {
+    "use strict";
+    mockFileMap = {};
+  }
+});
+
+// check.ts
+import fs3 from "fs-extra";
+import os from "os";
+import path4 from "path";
+import { spawn as spawn2 } from "child_process";
+import { WebSocketServer } from "ws";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { styleText as styleText2 } from "node:util";
+async function check(options) {
+  let log = options.log || console.log;
+  let mdFile = options.mdArg && normalizeMdFile(options.mdArg);
+  if (options.mdArg && !mdFile) {
+    log(`Couldn't find ${options.mdArg}`);
+    return false;
+  }
+  await loadWorkspace(config.root, !mdFile);
+  if (mdFile) {
+    if (process.env.NODE_ENV == "test" && mockFileMap[mdFile]) {
+      updateFile(mockFileMap[mdFile], mdFile);
+    } else {
+      let content = readFileSync2(path4.resolve(config.root, mdFile), "utf-8");
+      updateFile(content, mdFile);
+    }
+  }
+  analyze();
+  if (getDiagnostics().length > 0) {
+    printDiagnostics(getDiagnostics(), log);
+    return false;
+  }
+  if (!mdFile) {
+    log("No errors found \u{1F48E}");
+    return true;
+  }
+  let host = `http://localhost:${config.port || Number(process.env.GRAPHENE_PORT) || 4e3}`;
+  let pageUrl = "/" + mdFile.replace(/\.md$/, "").replace(/^\//, "").replace(/\\/g, "/");
+  if (pageUrl === "/index") pageUrl = "/";
+  if (process.env.NODE_ENV !== "test" && !await isServerRunning()) {
+    log("Starting Graphene server...");
+    await runServeInBackground();
+  }
+  let resp = await sendCheckRequest({ host, pageUrl, chart: options.chart });
+  if (resp.checkError == "no_server") {
+    log("Failed to start Graphene server");
+    return false;
+  }
+  if (resp.checkError == "no_tab" && process.env.NODE_ENV !== "test") {
+    log(`Opening page ${host}${pageUrl}`);
+    spawn2("open", [host + pageUrl]);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    resp = await sendCheckRequest({ host, pageUrl, chart: options.chart });
+  }
+  if (resp.checkError == "no_tab") {
+    log("Failed to open a new tab");
+    return false;
+  }
+  if (resp.checkError) {
+    log("Failed to run check: " + resp.checkError);
+    return false;
+  }
+  let errors = Array.from(resp.errors || []);
+  if (errors.length) {
+    log(styleText2("red", "Runtime errors") + ` in ${mdFile}:`);
+  } else {
+    log("No errors found \u{1F48E}");
+  }
+  errors.forEach((e) => {
+    if (e.file && e.line) printDiagnostics([e], log);
+    else if (e.id) log(`${e.id}: ${e.message}`);
+    else log(e.message);
+  });
+  if (resp?.stillLoading) {
+    log("Warning: Queries were still loading when the screenshot was taken");
+  }
+  if (resp?.screenshot) {
+    let filename = `graphene-screenshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
+    let screenshotPath = path4.join(os.tmpdir(), filename);
+    let base64Data = resp.screenshot.replace(/^data:image\/png;base64,/, "");
+    await fs3.writeFile(screenshotPath, base64Data, "base64");
+    log("Screenshot saved to", screenshotPath);
+  }
+  return errors.length == 0;
+}
+async function sendCheckRequest({ host, pageUrl, chart }) {
+  let abort = new AbortController();
+  let timeout = setTimeout(() => abort.abort(), 3e4);
+  try {
+    let response = await fetch(`${host}/_api/check`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ pageUrl: host + pageUrl, chart }),
+      signal: abort.signal
+    });
+    clearTimeout(timeout);
+    let body = response.headers.get("content-type") == "application/json" ? await response.json() : { error: await response.text() };
+    if (!response.ok) {
+      if (body.error) return { checkError: body.error };
+      console.error(`Unexpected response: ${JSON.stringify(body)}`);
+      return { checkError: "Unexpected response from Graphene server" };
+    }
+    return body;
+  } catch (err) {
+    clearTimeout(timeout);
+    if (err.name === "AbortError") return { checkError: "timeout" };
+    return { checkError: "no_server" };
+  }
+}
+function normalizeMdFile(mdFile) {
+  let clean = mdFile.trim();
+  if (!clean) return null;
+  if (!clean.endsWith(".md")) clean = clean + ".md";
+  if (process.env.NODE_ENV == "test" && mockFileMap[clean]) {
+    return clean;
+  }
+  let absolute = [
+    path4.resolve(process.cwd(), clean),
+    path4.resolve(config.root, clean)
+  ].find((p) => fs3.existsSync(p)) || null;
+  if (!absolute) return null;
+  let relative = path4.relative(config.root, absolute);
+  return relative;
+}
+async function proxyCheckRequest(req, res) {
+  let chunks = [];
+  for await (let chunk of req) chunks.push(chunk);
+  let { pageUrl, chart } = JSON.parse(Buffer.concat(chunks).toString());
+  let id = Math.random().toString(36).slice(2);
+  res.setHeader("Content-Type", "application/json");
+  let normalizedPageUrl = pageUrl.replace(/\/$/, "");
+  let conn = await pollFor(() => browserConnections.find((conn2) => conn2.url === normalizedPageUrl), 5e3, 100);
+  if (!conn) {
+    res.statusCode = 400;
+    res.end(JSON.stringify({ error: "no_tab" }));
+    return;
+  } else {
+    conn.socket.send(JSON.stringify({ type: "check", chart, requestId: id }));
+    pendingRequests[id] = { response: res };
+  }
+}
+function checkVitePlugin() {
+  return {
+    name: "graphene-check-plugin",
+    configureServer(server) {
+      let wss = new WebSocketServer({ noServer: true });
+      server.httpServer?.on("upgrade", (req, socket, head) => {
+        if (!req.url || !req.url.includes("/_api/ws") && !req.url.includes("graphene-ws")) return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          wss.emit("connection", ws, req);
+        });
+      });
+      wss.on("connection", (socket) => {
+        socket.on("message", (data) => {
+          let message = JSON.parse(data.toString());
+          if (message.type === "register") {
+            let normalizedUrl = message.url.replace(/\/$/, "");
+            browserConnections.push({ url: normalizedUrl, socket });
+          }
+          if (message.type === "checkResponse") {
+            pendingRequests[message.requestId].response.end(JSON.stringify(message));
+            delete pendingRequests[message.requestId];
+          }
+        });
+        socket.on("close", () => {
+          browserConnections = browserConnections.filter((conn) => conn.socket !== socket);
+        });
+      });
+      server.httpServer?.on("close", () => wss.close());
+      server.middlewares.use(async (req, res, next) => {
+        let [pathName] = (req.url || "").split("?");
+        if (pathName === "/_api/check") await proxyCheckRequest(req, res);
+        else next();
+      });
+    }
+  };
+}
+var browserConnections, pendingRequests;
+var init_check = __esm({
+  "check.ts"() {
+    "use strict";
+    init_core();
+    init_printer();
+    init_mockFiles();
+    init_background();
+    init_util();
+    browserConnections = [];
+    pendingRequests = {};
+  }
+});
+
+// auth.ts
+import fs4 from "node:fs/promises";
+import path5 from "path";
+import os2 from "os";
+import { spawn as spawn3 } from "child_process";
+import http from "http";
+async function readStore() {
+  try {
+    let txt2 = await fs4.readFile(credsPath, "utf8");
+    return JSON.parse(txt2) || {};
+  } catch {
+    return {};
+  }
+}
+async function readEntry() {
+  let store = await readStore();
+  return store[config.root];
+}
+async function updateEntry(cred) {
+  let store = await readStore();
+  cred.refresh_token ||= store[config.root]?.refresh_token;
+  cred.expires_at = Date.now() + cred.expires_in;
+  store[config.root] = cred;
+  await fs4.mkdir(path5.dirname(credsPath), { recursive: true, mode: 448 });
+  await fs4.writeFile(credsPath, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  if (process.platform !== "win32") {
+    await fs4.chmod(credsPath, 384).catch(() => {
+    });
+  }
+}
+function openInBrowser(url) {
+  try {
+    let plat = process.platform;
+    let cmd = "xdg-open";
+    if (plat == "darwin") cmd = "open";
+    if (plat == "win32") cmd = "start";
+    let p = spawn3(cmd, [url], { stdio: "ignore", shell: plat === "win32" });
+    p.unref();
+  } catch {
+    console.log(`Open this URL to authenticate:
+${url}`);
+  }
+}
+function base64url(buf) {
+  let b64 = Buffer.from(buf).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function randomBytes(len = 32) {
+  return crypto.getRandomValues(new Uint8Array(len));
+}
+async function startLoopback() {
+  let server = http.createServer();
+  await new Promise((r) => server.listen(0, "127.0.0.1", () => r()));
+  let addr = server.address();
+  if (!addr || typeof addr !== "object") throw new Error("Couldnt start oauth callback server");
+  let redirectBase = `http://localhost:${addr.port}`;
+  let waitForCode = new Promise((resolve) => {
+    server.on("request", (req, res) => {
+      let url = new URL(req.url || "/", redirectBase);
+      if (url.pathname !== "/callback") {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+      let code = url.searchParams.get("code") || "";
+      let state = url.searchParams.get("state") || "";
+      res.statusCode = 200;
+      res.setHeader("content-type", "text/html; charset=utf-8");
+      res.end("<html><body>Login complete. You may close this window.</body></html>");
+      resolve({ code, state });
+    });
+  });
+  return { url: redirectBase, waitForCode, close: () => server.close() };
+}
+async function loginPkce(opener) {
+  let verifier = base64url(randomBytes(48));
+  let data = new TextEncoder().encode(verifier);
+  let digest = await crypto.subtle.digest("SHA-256", data);
+  let code_challenge = base64url(digest);
+  let state = base64url(randomBytes(16));
+  let loop = await startLoopback();
+  let redirect_uri = `${loop.url}/callback`;
+  let authorizeUrl = new URL(`${config.host}/authenticate`);
+  authorizeUrl.search = new URLSearchParams({
+    redirect_uri,
+    code_challenge,
+    state,
+    client_id: AUTH_CLIENT_ID,
+    response_type: "code",
+    code_challenge_method: "S256",
+    scope: AUTH_SCOPES
+  }).toString();
+  if (opener) await opener(authorizeUrl.toString());
+  else openInBrowser(authorizeUrl.toString());
+  let result = await loop.waitForCode;
+  if (!result.code) throw new Error("No authorization code received");
+  if (result.state !== state) throw new Error("State mismatch");
+  let res = await fetch(`${config.host}/_api/oauth2/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code: result.code,
+      redirect_uri,
+      client_id: AUTH_CLIENT_ID,
+      code_verifier: verifier
+    })
+  });
+  if (!res.ok) throw new Error(`token exchange failed: ${res.status}`);
+  let tokenResp = await res.json();
+  await updateEntry(tokenResp);
+}
+async function refreshAccessToken() {
+  let refresh_token = (await readEntry())?.refresh_token;
+  let res = await fetch(new URL("/_api/oauth2/token", config.host).toString(), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ grant_type: "refresh_token", refresh_token, client_id: AUTH_CLIENT_ID })
+  });
+  if (!res.ok) throw new Error(`refresh failed: ${res.status}`);
+  let json = await res.json();
+  await updateEntry(json);
+}
+async function authenticatedFetch(pathOrUrl, init = {}) {
+  let entry = await readEntry();
+  if (!entry) throw new Error("Not logged in; run `graphene login`");
+  if (!entry.access_token || entry.expires_at < Date.now()) {
+    await refreshAccessToken();
+    entry = await readEntry();
+  }
+  let token = entry?.access_token;
+  if (!token) throw new Error("Failed to obtain access token");
+  let url = new URL(pathOrUrl, config.host);
+  let headers = new Headers(init.headers || {});
+  headers.set("authorization", `Bearer ${token}`);
+  let res = await fetch(url.toString(), { ...init, headers });
+  if (res.status === 401 || res.status === 403) {
+    await refreshAccessToken();
+    token = (await readEntry())?.access_token;
+    if (token) {
+      headers.set("cookie", `access_token=${token}`);
+      res = await fetch(url.toString(), { ...init, headers });
+    }
+  }
+  return res;
+}
+var AUTH_CLIENT_ID, AUTH_SCOPES, cfgDir, credsPath;
+var init_auth = __esm({
+  "auth.ts"() {
+    "use strict";
+    init_config();
+    AUTH_CLIENT_ID = "connected-app-test-4685a2a0-1cb9-4a81-a6bf-01a3efe7b981";
+    AUTH_SCOPES = "offline_access";
+    cfgDir = process.env.XDG_CONFIG_HOME || path5.join(os2.homedir(), ".config");
+    credsPath = path5.join(cfgDir, "graphene", "credentials.json");
+  }
+});
+
 // connections/bigQuery.ts
 var bigQuery_exports = {};
 __export(bigQuery_exports, {
@@ -1290,20 +2170,19 @@ import { BigQuery, BigQueryDate, BigQueryTimestamp } from "@google-cloud/bigquer
 var BigQueryConnection;
 var init_bigQuery = __esm({
   "connections/bigQuery.ts"() {
+    "use strict";
     init_config();
     BigQueryConnection = class {
       client;
       constructor(options = {}) {
+        options.projectId ||= config.bigquery?.projectId;
         if (process.env.GOOGLE_CREDENTIALS_CONTENT) {
           let parsed = JSON.parse(process.env.GOOGLE_CREDENTIALS_CONTENT);
           options.projectId = parsed.project_id;
           options.credentials = parsed;
         }
-        options.projectId ||= config.googleProjectId;
-        options.maxRetries ||= 3;
-        options.userAgent ||= "Graphene";
-        if (!options.projectId) throw new Error("googleProjectId must be set in config or provided in service account credentials");
-        this.client = new BigQuery(options);
+        if (!options.projectId) throw new Error("projectId must be set in config or provided in service account credentials");
+        this.client = new BigQuery({ ...options, userAgent: "Graphene" });
       }
       async runQuery(sql) {
         let [job] = await this.client.createQueryJob({ query: sql, useLegacySql: false });
@@ -1327,27 +2206,33 @@ var duckdb_exports = {};
 __export(duckdb_exports, {
   DuckDBConnection: () => DuckDBConnection
 });
-import { promises as fs3 } from "fs";
-import path4 from "path";
+import { promises as fs5 } from "fs";
+import path6 from "path";
 import { DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue } from "@duckdb/node-api";
 var DuckDBConnection;
 var init_duckdb = __esm({
   "connections/duckdb.ts"() {
+    "use strict";
     init_config();
     DuckDBConnection = class {
+      options;
       ready;
       connection = null;
-      constructor() {
+      constructor(options) {
+        this.options = options || {};
         this.ready = this.initialize();
       }
       async initialize() {
-        let files = await fs3.readdir(config.root);
-        let databasePath = files.find((f) => f.endsWith(".duckdb"));
-        if (!databasePath) throw new Error("No .duckdb file found in current directory");
-        databasePath = path4.resolve(config.root, databasePath);
+        let dbPath = this.options.path;
+        if (!dbPath) {
+          let files = await fs5.readdir(config.root);
+          dbPath = files.find((f) => f.endsWith(".duckdb"));
+          if (!dbPath) throw new Error("No .duckdb file found in current directory");
+          dbPath = path6.resolve(config.root, dbPath);
+        }
         let db = await DuckDBInstance.create(":memory:");
         this.connection = await db.connect();
-        let escapedPath = databasePath.replace(/'/g, "''");
+        let escapedPath = dbPath.replace(/'/g, "''");
         await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`);
         await this.connection.run("use graphene_cli;");
       }
@@ -1372,27 +2257,114 @@ var init_duckdb = __esm({
   }
 });
 
+// connections/snowflake.ts
+var snowflake_exports = {};
+__export(snowflake_exports, {
+  SnowflakeConnection: () => SnowflakeConnection
+});
+import { createPrivateKey } from "node:crypto";
+import snowflake from "snowflake-sdk";
+var SnowflakeConnection;
+var init_snowflake2 = __esm({
+  "connections/snowflake.ts"() {
+    "use strict";
+    init_config();
+    SnowflakeConnection = class {
+      ready;
+      connection;
+      constructor(opts) {
+        this.ready = this.initialize(opts || {});
+      }
+      async initialize(opts) {
+        let privateKeyPath = process.env.SNOWFLAKE_PRI_KEY_PATH || config.snowflake?.privateKeyPath;
+        let privateKeyPass = process.env.SNOWFLAKE_PRI_PASSPHRASE;
+        let authOptions = {};
+        if (privateKeyPath) {
+          authOptions = { privateKeyPath, privateKeyPass };
+        } else if (opts.privateKey) {
+          let privateKey = createPrivateKey({ key: opts.privateKey, format: "pem", passphrase: privateKeyPass });
+          authOptions = { privateKey: privateKey.export({ format: "pem", type: "pkcs8" }) };
+        }
+        snowflake.configure({ logLevel: process.env.SNOWFLAKE_LOG_LEVEL || "WARN", logFilePath: "/dev/null" });
+        this.connection = snowflake.createConnection({
+          ...opts,
+          ...config.snowflake || {},
+          ...authOptions,
+          authenticator: "SNOWFLAKE_JWT",
+          application: "Graphene"
+        });
+        await new Promise((resolve, reject) => {
+          this.connection.connect((err, conn) => err ? reject(err) : resolve(conn));
+        });
+      }
+      async runQuery(sql) {
+        await this.ready;
+        return await new Promise((resolve, reject) => {
+          let rows = [];
+          this.connection.execute({
+            sqlText: sql,
+            streamResult: true,
+            complete: (error, statement) => {
+              if (error) {
+                reject(new Error(`Snowflake query failed: ${error.message || error}`));
+                return;
+              }
+              let stream = statement.streamRows();
+              stream.on("error", (err) => reject(err));
+              stream.on("readable", function(row) {
+                while ((row = this.read()) !== null) {
+                  rows.push(row);
+                }
+              });
+              stream.on("end", () => {
+                let totalRows = Number(statement.getNumRows());
+                resolve({ rows, totalRows });
+              });
+            }
+          });
+        });
+      }
+    };
+  }
+});
+
 // connections/index.ts
-async function getConnection() {
+async function runQuery(sql) {
+  if (config.host) {
+    let resp = await authenticatedFetch("/_api/query", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sql })
+    });
+    return await resp.json();
+  }
   if (config.dialect === "bigquery") {
     let mod = await Promise.resolve().then(() => (init_bigQuery(), bigQuery_exports));
-    return new mod.BigQueryConnection();
+    let conn = new mod.BigQueryConnection();
+    return await conn.runQuery(sql);
   } else if (config.dialect === "duckdb") {
     let mod = await Promise.resolve().then(() => (init_duckdb(), duckdb_exports));
-    return new mod.DuckDBConnection();
+    let conn = new mod.DuckDBConnection({});
+    return await conn.runQuery(sql);
+  } else if (config.dialect === "snowflake") {
+    let mod = await Promise.resolve().then(() => (init_snowflake2(), snowflake_exports));
+    let conn = new mod.SnowflakeConnection({});
+    return await conn.runQuery(sql);
   } else {
     throw new Error(`Unsupported dialect: ${config.dialect}`);
   }
 }
 var init_connections = __esm({
   "connections/index.ts"() {
+    "use strict";
     init_config();
+    init_auth();
   }
 });
 
 // mdCompile.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { visit } from "unist-util-visit";
 import sanitizeHtml from "sanitize-html";
 function extractQueries() {
@@ -1469,13 +2441,14 @@ ${content}`;
 }
 function componentNames() {
   if (cachedComponentNames) return cachedComponentNames;
-  let files = fs4.readdirSync(path5.join(import.meta.dirname, "../ui/components"));
-  cachedComponentNames = files.map((f) => path5.basename(f, ".svelte")).filter((f) => !f.startsWith("_"));
+  let files = fs6.readdirSync(path7.join(import.meta.dirname, "../ui/components"));
+  cachedComponentNames = files.map((f) => path7.basename(f, ".svelte")).filter((f) => !f.startsWith("_"));
   return cachedComponentNames || [];
 }
 var cachedComponentNames;
 var init_mdCompile = __esm({
   "mdCompile.ts"() {
+    "use strict";
     cachedComponentNames = null;
   }
 });
@@ -1483,23 +2456,19 @@ var init_mdCompile = __esm({
 // serve2.ts
 var serve2_exports = {};
 __export(serve2_exports, {
-  mockFileMap: () => mockFileMap,
   serve2: () => serve2
 });
 import { createServer, optimizeDeps } from "vite";
 import { svelte, vitePreprocess } from "@sveltejs/vite-plugin-svelte";
-import fs5 from "fs-extra";
-import crypto from "crypto";
+import fs7 from "fs-extra";
+import crypto2 from "crypto";
 import { mdsvex } from "mdsvex";
-import path6 from "path";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { WebSocketServer } from "ws";
-import { spawn as spawn2 } from "child_process";
 async function serve2() {
-  grapheneRoot = config.root;
-  uiRoot = path6.join(fileURLToPath2(import.meta.url), "../../ui");
-  await fs5.ensureDir(path6.resolve(grapheneRoot, "node_modules/.graphene"));
-  await fs5.writeFile(path6.resolve(grapheneRoot, `node_modules/.graphene/${process.env.NODE_ENV == "test" ? "test" : "serve"}.pid`), String(process.pid));
+  uiRoot = path8.join(fileURLToPath2(import.meta.url), "../../ui");
+  let port = Number(process.env.GRAPHENE_PORT) || 4e3;
+  await fs7.ensureDir(path8.resolve(config.root, "node_modules/.graphene"));
   let server = await createServer({
     root: config.root,
     plugins: [
@@ -1515,24 +2484,30 @@ async function serve2() {
           injectComponentImports()
         ]
       }),
+      checkVitePlugin(),
       handleRequestPlugin,
       updateWorkspacePlugin,
       mockFilesForTests()
     ],
+    publicDir: path8.resolve(uiRoot),
     server: {
-      port: config.port,
+      port,
       fs: { strict: false },
       strictPort: true
     },
     resolve: {
       alias: {
-        graphene: path6.resolve(uiRoot, "web.js")
+        graphene: path8.resolve(uiRoot, "web.js")
       }
     }
+    // optimizeDeps: { // this seems prudent in tests, but currently breaks because ssf needs to be optimized, even in tests
+    //   noDiscovery: process.env.NODE_ENV == 'test',
+    //   include: process.env.NODE_ENV == 'test' ? [] : undefined,
+    // },
   });
   await optimizeDeps(server.config);
   await server.listen();
-  console.log(`Server running at http://localhost:${config.port}`);
+  console.log(`Server running at http://localhost:${port}`);
   return server;
 }
 async function handleQuery(req, res) {
@@ -1549,44 +2524,18 @@ async function handleQuery(req, res) {
   }
   if (queries.length > 1) throw new Error("Found multiple queries, which could be a parsing error");
   let sql = toSql(queries[0], params);
-  let hash = crypto.createHash("SHA1").update(sql).digest("hex");
+  let hash = crypto2.createHash("SHA1").update(sql).digest("hex");
   res.setHeader("ETag", hash);
   if (hashes.includes(hash) && req.headers["cache-control"] != "no-cache") {
     res.statusCode = 304;
     return res.end();
   }
-  let connection = await getConnection();
-  let queryResults = await connection.runQuery(sql);
+  let queryResults = await runQuery(sql);
   let totalRows = queryResults.totalRows ?? queryResults.rows.length;
   if (totalRows > queryResults.rows.length) throw new Error("Query returns too many rows");
   let fields = queries[0].fields.map((f) => ({ name: f.name, type: f.type }));
   res.end(JSON.stringify({ rows: queryResults.rows, hash, fields, sql }));
 }
-async function handleView(req, res) {
-  let chunks = [];
-  for await (let chunk of req) chunks.push(chunk);
-  let { mdFile, chart } = JSON.parse(Buffer.concat(chunks).toString());
-  let id = Math.random().toString(36).slice(2);
-  res.setHeader("Content-Type", "application/json");
-  viewRequests[id] = { response: res };
-  let pageUrl = "/" + mdFile.replace(/\.md$/, "").replace(/^\//, "");
-  if (pageUrl === "/index") pageUrl = "/";
-  pageUrl = `http://localhost:${config.port || 4e3}${pageUrl}`;
-  let conn = browserConnections.find((conn2) => conn2.url === pageUrl);
-  if (!conn) {
-    spawn2("open", [pageUrl]);
-    let end = Date.now() + 5e3;
-    while (Date.now() < end && !conn) {
-      conn = browserConnections.find((conn2) => conn2.url === pageUrl);
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    if (!conn) {
-      res.statusCode = 500;
-      return res.end(JSON.stringify({ error: "No browser tab available and failed to open one" }));
-    }
-  }
-  conn.socket.send(JSON.stringify({ type: "view", chart, requestId: id }));
-}
 async function handlePage(server, res, filePath, mount) {
   res.setHeader("Content-Type", "text/html");
   let mdMount = mount ? `
@@ -1599,7 +2548,7 @@ async function handlePage(server, res, filePath, mount) {
       <meta charset="UTF-8" />
       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
       <title>Graphene</title>
-      <link rel="icon" href="@graphenedata/ui/assets/favicon.ico" />
+      <link rel="icon" href="/assets/favicon.ico" />
       <link rel="preconnect" href="https://fonts.googleapis.com">
       <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
       <link href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap" rel="stylesheet">
@@ -1609,10 +2558,7 @@ async function handlePage(server, res, filePath, mount) {
         <div id="content"></div>
       </main>
       <script type="module">
-        // do this first so we can track errors caused by importing the md file
-        import 'graphene'
-      </script>
-      <script type="module">
+        import 'graphene' // do this first so we can track errors caused by importing the md file
         ${mdMount}
       </script>
     </body>
@@ -1625,63 +2571,45 @@ function mockFilesForTests() {
     name: "mock-files-for-tests",
     enforce: "pre",
     resolveId(id) {
-      if (mockFileMap[id.replace(grapheneRoot, "")]) return id + "?mock";
+      if (mockFileMap[id.replace(config.root + "/", "")]) return id + "?mock";
     },
     load(id) {
       if (!id.endsWith("?mock")) return null;
-      return mockFileMap[id.replace(grapheneRoot, "").replace(/\?mock$/, "")];
+      return mockFileMap[id.replace(config.root + "/", "").replace(/\?mock$/, "")];
     }
   };
 }
-var grapheneRoot, uiRoot, workspaceLoadPromise, updateWorkspacePlugin, handleRequestPlugin, browserConnections, viewRequests, mockFileMap;
+var uiRoot, workspaceLoadPromise, updateWorkspacePlugin, handleRequestPlugin;
 var init_serve2 = __esm({
   "serve2.ts"() {
+    "use strict";
     init_core();
     init_connections();
     init_mdCompile();
+    init_check();
+    init_mockFiles();
     updateWorkspacePlugin = {
       name: "updateWorkspace",
       configureServer: (s) => {
         s.watcher.add("**/*.gsql");
         s.watcher.on("change", () => {
           clearWorkspace();
-          workspaceLoadPromise = loadWorkspace(grapheneRoot, false);
+          workspaceLoadPromise = loadWorkspace(config.root, false);
         });
-        workspaceLoadPromise = loadWorkspace(grapheneRoot, false);
+        workspaceLoadPromise = loadWorkspace(config.root, false);
       }
     };
     handleRequestPlugin = {
       name: "handleRequest",
       configureServer: (s) => {
-        let wss = new WebSocketServer({ noServer: true });
-        s.httpServer.on("upgrade", (req, socket, head) => {
-          if (!req.url?.endsWith("/graphene-ws")) return;
-          wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit("connection", ws, req);
-          });
-        });
-        wss.on("connection", (socket) => {
-          socket.on("message", (data) => {
-            let message = JSON.parse(data.toString());
-            if (message.type === "register") {
-              browserConnections.push({ url: message.url, socket });
-            }
-            if (message.type === "viewResponse") {
-              viewRequests[message.requestId].response.end(JSON.stringify(message));
-              delete viewRequests[message.requestId];
-            }
-          });
-          socket.on("close", () => browserConnections = browserConnections.filter((conn) => conn.socket !== socket));
-        });
         s.middlewares.use(async function handleRequest(req, res, next) {
           try {
             let [pathName] = (req.url || "").split("?");
             if (pathName == "/_api/query") return await handleQuery(req, res);
-            if (pathName == "/graphene/view") return await handleView(req, res);
             if (pathName == "/__ct") return await handlePage(s, res, "__ct", false);
             if (!pathName || pathName == "/") pathName = "index";
-            let mdPath = path6.join(grapheneRoot, pathName + ".md");
-            if (await fs5.exists(mdPath)) {
+            let mdPath = path8.join(config.root, pathName + ".md");
+            if (await fs7.exists(mdPath)) {
               await handlePage(s, res, mdPath, true);
             } else {
               next();
@@ -1694,166 +2622,20 @@ var init_serve2 = __esm({
         });
       }
     };
-    browserConnections = [];
-    viewRequests = {};
-    mockFileMap = {};
   }
 });
 
 // cli.ts
-import { Command } from "commander";
-
-// printer.ts
-init_core();
-import { styleText as nodeStyleText } from "node:util";
-import Table from "cli-table3";
-import chalk from "chalk";
-var styleText = (style, text) => {
-  try {
-    return nodeStyleText ? nodeStyleText(style, text) : text;
-  } catch {
-    return text;
-  }
-};
-function offsetToLineCol(src, offset2) {
-  let lines = src.split(/\r?\n/);
-  let acc = 0;
-  for (let i = 0; i < lines.length; i++) {
-    let lineText = lines[i];
-    let nextAcc = acc + lineText.length + 1;
-    if (offset2 < nextAcc || i === lines.length - 1) {
-      let col = Math.max(0, offset2 - acc);
-      return { line: i + 1, col, lineStart: acc, lineText };
-    }
-    acc = nextAcc;
-  }
-  return { line: 1, col: 0, lineStart: 0, lineText: lines[0] || "" };
-}
-function printDiagnostics(diags) {
-  let parts = [];
-  for (let d of diags) {
-    let src = getFile2(d.file)?.contents || "";
-    let { line, col, lineStart, lineText } = offsetToLineCol(src, d.from.offset);
-    let endCol = Math.max(col + 1, Math.min(lineText.length, d.to.offset - lineStart));
-    let caretLen = Math.max(1, endCol - col);
-    let sev = d.severity === "error" ? "red" : "yellow";
-    let header = `${styleText(sev, d.severity.toUpperCase())}: ${d.file} line ${line}: ${d.message}`;
-    let gutter = "   | ";
-    let caretLine = `${" ".repeat(col)}${styleText(sev, "^".repeat(caretLen))}`;
-    parts.push([header, `${gutter}${lineText}`, `${gutter}${caretLine}`].join("\n"));
-  }
-  if (parts.length) console.error(parts.join("\n"));
-}
-function printTable(rows) {
-  if (!rows || rows.length === 0) {
-    console.log(chalk.yellow("No results returned"));
-    return;
-  }
-  let headers = Object.keys(rows[0]);
-  let table2 = new Table({ head: headers.map((h) => chalk.blue(h)) });
-  let MAX_DISPLAY_ROWS = 200;
-  let displayRows = rows.slice(0, MAX_DISPLAY_ROWS);
-  displayRows.forEach((row) => table2.push(headers.map((h) => row[h]?.toString() || "")));
-  console.log(table2.toString());
-  if (rows.length > MAX_DISPLAY_ROWS) {
-    console.log(chalk.yellow(`Displayed first ${MAX_DISPLAY_ROWS} rows (of ${rows.length} total).`));
-  }
-}
-
-// cli.ts
+init_printer();
 init_core();
 init_config();
-import fs6 from "fs-extra";
-import path7 from "path";
-import os from "os";
-
-// background.ts
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
-import fs2 from "fs-extra";
-import path3 from "path";
-async function runServeInBackground() {
-  let root = process.cwd();
-  let grapheneCache = getGrapheneCache(root);
-  let logFile = path3.join(grapheneCache, "serve.log");
-  await fs2.ensureDir(grapheneCache);
-  await stopGrapheneIfRunning(root);
-  let log = fs2.openSync(logFile, "w");
-  let entryPoint = process.argv[1] || fileURLToPath(import.meta.url);
-  let childArgs = [...process.execArgv, entryPoint, "serve", "--fg", ...process.argv.slice(3)];
-  let child = spawn(process.execPath, childArgs, {
-    cwd: root,
-    detached: true,
-    env: { ...process.env },
-    stdio: ["ignore", log, log]
-  });
-  if (!child.pid) throw new Error("Failed to start server process");
-  await new Promise((resolve, reject) => {
-    let buffer = "";
-    fs2.watchFile(logFile, { interval: 200 }, (curr, prev) => {
-      if (curr.size > prev.size) {
-        let stream = fs2.createReadStream(logFile, { start: 0, end: curr.size - 1 });
-        stream.on("data", (d) => {
-          process.stdout.write(d);
-          buffer = (buffer + d.toString()).slice(-200);
-          if (buffer.includes("Server running at http://localhost:")) resolve();
-        });
-      }
-    });
-    child.once("exit", () => {
-      process.stdout.write(fs2.readFileSync(logFile));
-      reject(new Error("Exited before server started"));
-    });
-    child.once("error", (e) => reject(e));
-  });
-}
-function getGrapheneCache(root) {
-  return path3.join(root, "node_modules", ".graphene");
-}
-function getPidFilePath(root) {
-  return path3.join(getGrapheneCache(root), process.env.NODE_ENV == "test" ? "test.pid" : "serve.pid");
-}
-async function stopGrapheneIfRunning(root) {
-  let pidFile = getPidFilePath(root);
-  let pid = await readPid(pidFile);
-  if (!pid) return true;
-  if (!isProcessRunning(pid)) {
-    await fs2.remove(pidFile);
-    return true;
-  }
-  try {
-    console.log(`Stopping server (${pid})`);
-    process.kill(pid, "SIGTERM");
-  } catch (err) {
-    if (err.code === "ESRCH") return true;
-    return false;
-  }
-  let end = Date.now() + 5e3;
-  while (Date.now() < end && isProcessRunning(pid)) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  await fs2.remove(pidFile);
-  return !isProcessRunning(pid);
-}
-async function readPid(pidFile) {
-  if (!await fs2.pathExists(pidFile)) return void 0;
-  let contents = (await fs2.readFile(pidFile, "utf8")).trim();
-  if (!contents) return void 0;
-  let pid = Number.parseInt(contents, 10);
-  if (Number.isNaN(pid)) return void 0;
-  return pid;
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// cli.ts
+init_background();
+init_check();
 init_connections();
+init_auth();
+import { Command } from "commander";
+import fs8 from "fs-extra";
+import path9 from "path";
 var program = new Command();
 program.name("graphene").description("Graphene CLI").version("1.0.0");
 program.hook("preAction", async () => {
@@ -1875,53 +2657,30 @@ program.command("run").description("Run a query against your database").argument
   let queries = analyze(gsql);
   if (!validQuery(queries)) return;
   let sql = toSql(queries[0]);
-  let connection = await getConnection();
-  let res = await connection.runQuery(sql);
+  let res = await runQuery(sql);
   printTable(res.rows);
 });
-program.command("serve").description("Run the local server").option("--fg", "Run the server in the foreground").action(async (options) => {
-  if (options.fg || process.env.DEBUG) {
-    let mod = await Promise.resolve().then(() => (init_serve2(), serve2_exports));
-    await mod.serve2();
-  } else {
+program.command("serve").description("Run the local server").option("--bg", "Run the server in the background").action(async (options) => {
+  await stopGrapheneIfRunning();
+  if (options.bg) {
     await runServeInBackground();
     process.exit(0);
+  } else {
+    let mod = await Promise.resolve().then(() => (init_serve2(), serve2_exports));
+    await mod.serve2();
   }
 });
 program.command("stop").description("Stop the local server").action(async () => {
-  await stopGrapheneIfRunning(process.cwd());
+  await stopGrapheneIfRunning();
 });
-program.command("check").description("Check the project for errors").action(async () => {
-  await loadWorkspace(process.cwd(), true);
-  analyze();
-  if (getDiagnostics().length) {
-    printDiagnostics(getDiagnostics());
-    process.exit(1);
-  }
-  console.log("No errors found \u{1F48E}");
+program.command("check").description("Check the project for errors, optionally capturing a page screenshot").argument("[mdFile]", "Markdown file to check (e.g., index.md)").option("-c, --chart <chartTitle>", "Title of a specific chart to capture").action(async (mdArg, options) => {
+  let res = await check({ mdArg, chart: options.chart });
+  process.exit(res ? 0 : 1);
 });
-program.command("view").description("Capture a screenshot of a rendered markdown file").argument("<mdFile>", "Markdown file to view (e.g., index.md)").option("-c, --chart <chartName>", "Name of specific chart to capture").action(async (mdFile, options) => {
-  let response = await fetch("http://localhost:4000/graphene/view", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ mdFile, chart: options.chart })
-  });
-  if (!response.ok) throw new Error(`View request failed: ${await response.text()}`);
-  let result = await response.json();
-  if (result.errors && result.errors.length > 0) {
-    console.error("Errors found:");
-    result.errors.forEach((error) => console.error(JSON.stringify(error)));
-  }
-  if (result.stillLoading) {
-    console.error("Warning: Queries were still loading when the screenshot was taken");
-  }
-  if (result.screenshot) {
-    let filename = `graphene-screenshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
-    let screenshotPath = path7.join(os.tmpdir(), filename);
-    let base64Data = result.screenshot.replace(/^data:image\/png;base64,/, "");
-    await fs6.writeFile(screenshotPath, base64Data, "base64");
-    console.log("Screenshot saved to", screenshotPath);
-  }
+program.command("login").description("Log in to Graphene Cloud").action(async () => {
+  await loginPkce();
+  console.log("Successfully logged in");
+  process.exit(0);
 });
 program.parse(process.argv);
 async function readInput(arg) {
@@ -1934,9 +2693,9 @@ async function readInput(arg) {
       process.stdin.resume();
     });
   }
-  let absolutePath = path7.resolve(arg);
-  if (fs6.existsSync(absolutePath)) {
-    return await fs6.promises.readFile(absolutePath, "utf-8");
+  let absolutePath = path9.resolve(arg);
+  if (fs8.existsSync(absolutePath)) {
+    return await fs8.promises.readFile(absolutePath, "utf-8");
   }
   return arg;
 }