@graphenedata/cli 0.0.17 → 0.0.18

package/dist/cli/{chunk-TZTTALAV.js → chunk-UTV3ERGI.js}

@@ -1,6 +1,6 @@
 import {
   config
-} from "./chunk-56K2FF57.js";
+} from "./chunk-SQVXTHE5.js";
 
 // ../lang/types.ts
 var SCALAR_TYPE_ALIASES = {
@@ -211,11 +211,41 @@ function multiGrainMessage(paths) {
 function normalizeTemporalPart(rawPart) {
   return String(rawPart || "").trim().replace(/^['"]|['"]$/g, "").toLowerCase();
 }
-function inferTemporalPart(rawPart) {
+function inferGrain(rawPart) {
   let normalized = normalizeTemporalPart(rawPart);
   if (!normalized) return;
-  if (/^week(?:\([a-z]+\))?$/.test(normalized)) return "week";
-  let parts = {
+  if (/^week(?:\([a-z]+\))?$/.test(normalized) || normalized == "isoweek") return { timeGrain: "week", defaultName: "week" };
+  if (normalized == "isoyear") return { timeGrain: "year", defaultName: "year" };
+  switch (normalized) {
+    case "year":
+    case "quarter":
+    case "month":
+    case "day":
+    case "hour":
+    case "minute":
+    case "second":
+      return { timeGrain: normalized, defaultName: normalized };
+  }
+}
+function inferTimeOrdinal(rawPart, dialect) {
+  let normalized = normalizeTemporalPart(rawPart);
+  if (normalized == "year" || normalized == "isoyear") return { timeGrain: "year", defaultName: "year" };
+  let timeOrdinal;
+  if (normalized == "hour") timeOrdinal = "hour_of_day";
+  if (normalized == "day" || normalized == "dayofmonth") timeOrdinal = "day_of_month";
+  if (normalized == "dayofyear" || normalized == "doy") timeOrdinal = "day_of_year";
+  if (normalized == "week" || normalized == "weekofyear" || normalized == "isoweek" || /^week(?:\([a-z]+\))?$/.test(normalized)) timeOrdinal = "week_of_year";
+  if (normalized == "month") timeOrdinal = "month_of_year";
+  if (normalized == "quarter") timeOrdinal = "quarter_of_year";
+  if (normalized == "isodow" || normalized == "dayofweekiso" || normalized == "iso_dayofweek") timeOrdinal = "dow_1m";
+  if (normalized == "dayofweek" || normalized == "dow" || normalized == "weekday") {
+    if (dialect == "bigquery") timeOrdinal = "dow_1s";
+    else if (dialect == "clickhouse") timeOrdinal = "dow_1m";
+    else timeOrdinal = "dow_0s";
+  }
+  if (!timeOrdinal) return;
+  if (/^week(?:\([a-z]+\))?$/.test(normalized)) return { timeOrdinal, defaultName: "week" };
+  let defaultNames = {
     dow: "dayofweek",
     weekday: "dayofweek",
     dayofmonth: "day",
@@ -224,52 +254,7 @@ function inferTemporalPart(rawPart) {
     dayofweekiso: "isodow",
     iso_dayofweek: "isodow"
   };
-  return parts[normalized] || normalized;
-}
-function inferTemporalGrain(rawPart) {
-  let normalized = normalizeTemporalPart(rawPart);
-  if (!normalized) return;
-  if (/^week(?:\([a-z]+\))?$/.test(normalized) || normalized == "isoweek") return "week";
-  if (normalized == "isoyear") return "year";
-  let grains = {
-    year: "year",
-    quarter: "quarter",
-    month: "month",
-    day: "day",
-    hour: "hour",
-    minute: "minute",
-    second: "second"
-  };
-  return grains[normalized];
-}
-function inferTemporalGrainMetadata(rawPart) {
-  let timeGrain = inferTemporalGrain(rawPart);
-  return timeGrain ? { timeGrain, defaultName: timeGrain } : void 0;
-}
-function inferTemporalOrdinal(rawPart, dialect) {
-  let normalized = normalizeTemporalPart(rawPart);
-  if (!normalized) return;
-  if (normalized == "hour") return "hour_of_day";
-  if (normalized == "day" || normalized == "dayofmonth") return "day_of_month";
-  if (normalized == "dayofyear" || normalized == "doy") return "day_of_year";
-  if (normalized == "week" || normalized == "weekofyear" || normalized == "isoweek") return "week_of_year";
-  if (normalized == "month") return "month_of_year";
-  if (normalized == "quarter") return "quarter_of_year";
-  if (normalized == "isodow" || normalized == "dayofweekiso" || normalized == "iso_dayofweek") return "dow_1m";
-  if (normalized == "dayofweek" || normalized == "dow" || normalized == "weekday") {
-    if (dialect == "bigquery") return "dow_1s";
-    if (dialect == "clickhouse") return "dow_1m";
-    return "dow_0s";
-  }
-}
-function inferTemporalExtractionMetadata(rawPart, dialect) {
-  let timePart = inferTemporalPart(rawPart);
-  let timeOrdinal = inferTemporalOrdinal(rawPart, dialect);
-  if (!timePart && !timeOrdinal) return;
-  return {
-    ...timePart ? { timePart, defaultName: timePart } : {},
-    ...timeOrdinal ? { timeOrdinal } : {}
-  };
+  return { timeOrdinal, defaultName: defaultNames[normalized] || normalized };
 }
 
 // ../lang/util.ts
@@ -2296,7 +2281,7 @@ var bigQueryFunctions = [
       { name: "date_part", type: "kw", description: "The date part to truncate to." }
     ],
     returns: "T",
-    metadata: (args) => inferTemporalGrainMetadata(args[1]?.sql),
+    metadata: (args) => inferGrain(args[1]?.sql),
     sqlTemplate: "DATE_TRUNC(${date_expression}, ${date_part})"
   },
   {
@@ -2499,7 +2484,7 @@ var bigQueryFunctions = [
       { name: "part", type: "string", description: "The part to truncate to." }
     ],
     returns: "datetime",
-    metadata: (args) => inferTemporalGrainMetadata(args[1]?.sql)
+    metadata: (args) => inferGrain(args[1]?.sql)
   },
   {
     name: "format_datetime",
@@ -2657,7 +2642,7 @@ var bigQueryFunctions = [
       { name: "part", type: "string", description: "The part to truncate to." }
     ],
     returns: "time",
-    metadata: (args) => inferTemporalGrainMetadata(args[1]?.sql)
+    metadata: (args) => inferGrain(args[1]?.sql)
   },
   {
     name: "format_time",
@@ -2811,7 +2796,7 @@ var bigQueryFunctions = [
       { name: "time_zone", type: "string?", description: "The time zone to use." }
     ],
     returns: "timestamp",
-    metadata: (args) => inferTemporalGrainMetadata(args[1]?.sql)
+    metadata: (args) => inferGrain(args[1]?.sql)
   },
   {
     name: "format_timestamp",
@@ -4646,7 +4631,7 @@ var clickHouseFunctions = [
       { name: "datetime", type: ["date", "timestamp"] }
     ],
     returns: "timestamp",
-    metadata: (args) => inferTemporalGrainMetadata(args[0]?.sql),
+    metadata: (args) => inferGrain(args[0]?.sql),
     sqlTemplate: "DATE_TRUNC(${date_part}, ${datetime})"
   },
   {
@@ -4736,7 +4721,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#todayofmonth`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("day", "clickhouse"),
+    metadata: inferTimeOrdinal("day", "clickhouse"),
     sqlName: "toDayOfMonth",
     aliases: ["to_day_of_month"]
   },
@@ -4750,7 +4735,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#todayofyear`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofyear", "clickhouse"),
+    metadata: inferTimeOrdinal("dayofyear", "clickhouse"),
     sqlName: "toDayOfYear",
     aliases: ["to_day_of_year"]
   },
@@ -4764,7 +4749,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#todayofweek`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofweek", "clickhouse"),
+    metadata: inferTimeOrdinal("dayofweek", "clickhouse"),
     sqlName: "toDayOfWeek",
     aliases: ["to_day_of_week"]
   },
@@ -4778,7 +4763,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#tohour`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("hour", "clickhouse"),
+    metadata: inferTimeOrdinal("hour", "clickhouse"),
     sqlName: "toHour",
     aliases: ["to_hour"]
   },
@@ -4792,7 +4777,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#tominute`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("minute", "clickhouse"),
+    metadata: inferTimeOrdinal("minute", "clickhouse"),
     sqlName: "toMinute",
     aliases: ["to_minute"]
   },
@@ -4806,7 +4791,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#tomonth`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("month", "clickhouse"),
+    metadata: inferTimeOrdinal("month", "clickhouse"),
     sqlName: "toMonth",
     aliases: ["to_month"]
   },
@@ -4820,7 +4805,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#toquarter`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("quarter", "clickhouse"),
+    metadata: inferTimeOrdinal("quarter", "clickhouse"),
     sqlName: "toQuarter",
     aliases: ["to_quarter"]
   },
@@ -4834,7 +4819,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#tosecond`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("second", "clickhouse"),
+    metadata: inferTimeOrdinal("second", "clickhouse"),
     sqlName: "toSecond",
     aliases: ["to_second"]
   },
@@ -4848,7 +4833,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#toweek`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("week", "clickhouse"),
+    metadata: inferTimeOrdinal("week", "clickhouse"),
     sqlName: "toWeek",
     aliases: ["to_week"]
   },
@@ -4932,7 +4917,7 @@ var clickHouseFunctions = [
     url: `${click}/functions/date-time-functions#toyear`,
     args: [{ name: "datetime", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("year", "clickhouse"),
+    metadata: inferTimeOrdinal("year", "clickhouse"),
     sqlName: "toYear",
     aliases: ["to_year"]
   }
@@ -6707,7 +6692,7 @@ var duckDbFunctions = [
       { name: "date", type: ["date", "timestamp"] }
     ],
     returns: "number",
-    metadata: (args) => inferTemporalExtractionMetadata(args[0]?.sql, "duckdb")
+    metadata: (args) => inferTimeOrdinal(args[0]?.sql, "duckdb")
   },
   {
     name: "year",
@@ -6719,7 +6704,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("year", "duckdb")
+    metadata: inferTimeOrdinal("year", "duckdb")
   },
   {
     name: "quarter",
@@ -6731,7 +6716,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("quarter", "duckdb")
+    metadata: inferTimeOrdinal("quarter", "duckdb")
   },
   {
     name: "month",
@@ -6743,7 +6728,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("month", "duckdb")
+    metadata: inferTimeOrdinal("month", "duckdb")
   },
   {
     name: "week",
@@ -6755,7 +6740,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("week", "duckdb")
+    metadata: inferTimeOrdinal("week", "duckdb")
   },
   {
     name: "weekofyear",
@@ -6767,7 +6752,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("weekofyear", "duckdb")
+    metadata: inferTimeOrdinal("weekofyear", "duckdb")
   },
   {
     name: "day",
@@ -6779,7 +6764,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("day", "duckdb")
+    metadata: inferTimeOrdinal("day", "duckdb")
   },
   {
     name: "dayofmonth",
@@ -6791,7 +6776,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofmonth", "duckdb")
+    metadata: inferTimeOrdinal("dayofmonth", "duckdb")
   },
   {
     name: "dayofweek",
@@ -6803,7 +6788,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofweek", "duckdb")
+    metadata: inferTimeOrdinal("dayofweek", "duckdb")
   },
   {
     name: "weekday",
@@ -6815,7 +6800,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("weekday", "duckdb")
+    metadata: inferTimeOrdinal("weekday", "duckdb")
   },
   {
     name: "dayofyear",
@@ -6827,7 +6812,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofyear", "duckdb")
+    metadata: inferTimeOrdinal("dayofyear", "duckdb")
   },
   {
     name: "hour",
@@ -6839,7 +6824,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("hour", "duckdb")
+    metadata: inferTimeOrdinal("hour", "duckdb")
   },
   {
     name: "minute",
@@ -6851,7 +6836,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("minute", "duckdb")
+    metadata: inferTimeOrdinal("minute", "duckdb")
   },
   {
     name: "second",
@@ -6863,7 +6848,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("second", "duckdb")
+    metadata: inferTimeOrdinal("second", "duckdb")
   },
   {
     name: "isodow",
@@ -6875,7 +6860,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("isodow", "duckdb")
+    metadata: inferTimeOrdinal("isodow", "duckdb")
   },
   {
     name: "isoyear",
@@ -6887,7 +6872,7 @@ var duckDbFunctions = [
     url: `${duck}/datepart.html`,
     args: [{ name: "date", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("isoyear", "duckdb")
+    metadata: inferTimeOrdinal("isoyear", "duckdb")
   },
   {
     name: "date_sub",
@@ -7187,7 +7172,7 @@ var duckDbFunctions = [
       { name: "timestamp", type: ["date", "timestamp"] }
     ],
     returns: "timestamp",
-    metadata: (args) => inferTemporalGrainMetadata(args[0]?.sql),
+    metadata: (args) => inferGrain(args[0]?.sql),
     sqlTemplate: "DATE_TRUNC(${part}, ${timestamp})"
   },
   {
@@ -9085,7 +9070,7 @@ var snowflakeFunctions = [
       { name: "date_expr", type: ["date", "timestamp"] }
     ],
     returns: "number",
-    metadata: (args) => inferTemporalExtractionMetadata(args[0]?.sql, "snowflake")
+    metadata: (args) => inferTimeOrdinal(args[0]?.sql, "snowflake")
   },
   {
     name: "dateadd",
@@ -9225,7 +9210,7 @@ var snowflakeFunctions = [
       { name: "date_or_time_part", type: "string" }
     ],
     returns: "timestamp",
-    metadata: (args) => inferTemporalGrainMetadata(args[2]?.sql)
+    metadata: (args) => inferGrain(args[2]?.sql)
   },
   {
     name: "timestamp_from_parts",
@@ -9272,7 +9257,7 @@ var snowflakeFunctions = [
     url: `${sf}/year`,
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("year", "snowflake")
+    metadata: inferTimeOrdinal("year", "snowflake")
   },
   {
     name: "month",
@@ -9284,7 +9269,7 @@ var snowflakeFunctions = [
     url: `${sf}/year`,
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("month", "snowflake")
+    metadata: inferTimeOrdinal("month", "snowflake")
   },
   {
     name: "day",
@@ -9298,7 +9283,7 @@ var snowflakeFunctions = [
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
     aliases: ["dayofmonth"],
-    metadata: inferTemporalExtractionMetadata("day", "snowflake")
+    metadata: inferTimeOrdinal("day", "snowflake")
   },
   {
     name: "dayofweek",
@@ -9310,7 +9295,7 @@ var snowflakeFunctions = [
     url: `${sf}/year`,
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofweek", "snowflake")
+    metadata: inferTimeOrdinal("dayofweek", "snowflake")
   },
   {
     name: "dayofyear",
@@ -9322,7 +9307,7 @@ var snowflakeFunctions = [
     url: `${sf}/year`,
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("dayofyear", "snowflake")
+    metadata: inferTimeOrdinal("dayofyear", "snowflake")
   },
   {
     name: "week",
@@ -9336,7 +9321,7 @@ var snowflakeFunctions = [
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
     aliases: ["weekofyear"],
-    metadata: inferTemporalExtractionMetadata("week", "snowflake")
+    metadata: inferTimeOrdinal("week", "snowflake")
   },
   {
     name: "quarter",
@@ -9348,7 +9333,7 @@ var snowflakeFunctions = [
     url: `${sf}/year`,
     args: [{ name: "date_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("quarter", "snowflake")
+    metadata: inferTimeOrdinal("quarter", "snowflake")
   },
   {
     name: "hour",
@@ -9360,7 +9345,7 @@ var snowflakeFunctions = [
     url: `${sf}/hour-minute-second`,
     args: [{ name: "time_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("hour", "snowflake")
+    metadata: inferTimeOrdinal("hour", "snowflake")
   },
   {
     name: "minute",
@@ -9372,7 +9357,7 @@ var snowflakeFunctions = [
     url: `${sf}/hour-minute-second`,
     args: [{ name: "time_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("minute", "snowflake")
+    metadata: inferTimeOrdinal("minute", "snowflake")
   },
   {
     name: "second",
@@ -9384,7 +9369,7 @@ var snowflakeFunctions = [
     url: `${sf}/hour-minute-second`,
     args: [{ name: "time_expr", type: ["date", "timestamp"] }],
     returns: "number",
-    metadata: inferTemporalExtractionMetadata("second", "snowflake")
+    metadata: inferTimeOrdinal("second", "snowflake")
   },
   // ============================================================================
   // Conditional Functions
@@ -9630,7 +9615,7 @@ var snowflakeFunctions = [
       { name: "date_expr", type: ["date", "timestamp"] }
     ],
     returns: "timestamp",
-    metadata: (args) => inferTemporalGrainMetadata(args[0]?.sql),
+    metadata: (args) => inferGrain(args[0]?.sql),
     sqlTemplate: "DATE_TRUNC(${part}, ${date_expr})"
   },
   {
@@ -10455,9 +10440,21 @@ function isFence(event) {
 
 // ../lang/metadata.ts
 var embeddedMetadataPair = /(^|\s)(#)([A-Za-z0-9_-]+)(?:\s*=\s*("(?:[^"\\]|\\.)*"|[^\s#]+)|(?=(?:\s*(?:#|--|$))))/g;
-function extractLeadingMetadata(node) {
+var isoCurrencyCodes = new Set(Intl.supportedValuesOf("currency").map((code) => code.toLowerCase()));
+var metadataKeyRules = {
+  ratio: { kind: "flag" },
+  pct: { kind: "flag" },
+  pii: { kind: "flag" },
+  currency: { kind: "currency" },
+  unit: { kind: "string" },
+  timeGrain: { kind: "enum", values: ["year", "quarter", "month", "week", "day", "hour", "minute", "second"] },
+  timeOrdinal: { kind: "enum", values: ["hour_of_day", "day_of_month", "day_of_year", "week_of_year", "month_of_year", "quarter_of_year", "dow_0s", "dow_1s", "dow_1m"] },
+  description: { kind: "string" }
+};
+var validMetadataKeys = Object.keys(metadataKeyRules);
+function extractLeadingMetadataDetails(node) {
   let src = getFile(node).contents;
-  if (!src) return {};
+  if (!src) return { metadata: {}, entries: [] };
   let pos = node.from;
   let currentLineStart = src.lastIndexOf("\n", Math.max(0, pos - 1)) + 1;
   let endOfPrevLine = currentLineStart - 1;
@@ -10468,9 +10465,10 @@ function extractLeadingMetadata(node) {
     let cursor = endOfPrevLine;
     while (cursor >= 0) {
       let startOfLine = src.lastIndexOf("\n", Math.max(0, cursor - 1)) + 1;
-      let trimmed = src.slice(startOfLine, cursor).trim();
+      let line = src.slice(startOfLine, cursor);
+      let trimmed = line.trim();
       if (!trimmed) break;
-      let comment = parseCommentLine(trimmed);
+      let comment = parseCommentLine(line, startOfLine);
       if (!comment) break;
       comments.push(comment);
       cursor = startOfLine - 1;
@@ -10479,63 +10477,161 @@ function extractLeadingMetadata(node) {
   comments.reverse();
   let metadata = {};
   let descriptionLines = [];
-  for (let comment of comments) consumeComment(comment, metadata, descriptionLines);
+  let entries = [];
+  for (let comment of comments) consumeComment(comment, metadata, descriptionLines, entries);
   let endPos = node.to;
   let endOfLine = src.indexOf("\n", endPos);
   if (endOfLine === -1) endOfLine = src.length;
   let after = src.slice(endPos, endOfLine);
-  let trailing = parseTrailingComment(after);
-  if (trailing) consumeComment(trailing, metadata, descriptionLines);
+  let trailing = parseTrailingComment(after, endPos);
+  if (trailing) consumeComment(trailing, metadata, descriptionLines, entries);
   if (descriptionLines.length) metadata.description = descriptionLines.join(" ");
-  return metadata;
+  return { metadata, entries };
+}
+function validateMetadataEntries(entries) {
+  let diagnostics = [];
+  for (let entry of entries) {
+    let rule = metadataKeyRules[entry.key];
+    if (!rule) {
+      diagnostics.push({
+        message: `Unknown metadata key "#${entry.key}". Expected one of: ${validMetadataKeys.join(", ")}`,
+        from: entry.from,
+        to: entry.to
+      });
+      continue;
+    }
+    if (rule.kind == "flag") {
+      if (!entry.hasValue || entry.rawValue == "true") continue;
+      diagnostics.push({
+        message: `Metadata "#${entry.key}" is a flag; use "#${entry.key}" or "#${entry.key}=true".`,
+        from: entry.valueFrom ?? entry.from,
+        to: entry.valueTo ?? entry.to
+      });
+      continue;
+    }
+    if (rule.kind == "string") {
+      if (entry.hasValue && entry.value.trim()) continue;
+      diagnostics.push({
+        message: `Metadata "#${entry.key}" requires a value.`,
+        from: entry.from,
+        to: entry.to
+      });
+      continue;
+    }
+    if (rule.kind == "currency") {
+      if (!entry.hasValue || !entry.value.trim()) {
+        diagnostics.push({
+          message: 'Metadata "#currency" requires a value.',
+          from: entry.from,
+          to: entry.to
+        });
+        continue;
+      }
+      if (isoCurrencyCodes.has(entry.value.toLowerCase())) continue;
+      diagnostics.push({
+        message: `Invalid value "${entry.value}" for "#currency". Expected an ISO 4217 currency code.`,
+        from: entry.valueFrom ?? entry.from,
+        to: entry.valueTo ?? entry.to
+      });
+      continue;
+    }
+    if (rule.values.includes(entry.value)) continue;
+    diagnostics.push({
+      message: `Invalid value "${entry.value}" for "#${entry.key}". Expected one of: ${rule.values.join(", ")}`,
+      from: entry.valueFrom ?? entry.from,
+      to: entry.valueTo ?? entry.to
+    });
+  }
+  return diagnostics;
 }
-function parseCommentLine(trimmed) {
-  if (trimmed.startsWith("--")) return { kind: "dash", text: trimmed.slice(2).trimStart() };
-  if (trimmed.startsWith("#")) return { kind: "hash", text: trimmed.slice(1).trimStart() };
+function parseCommentLine(line, lineStart) {
+  let leading = line.match(/^\s*/)?.[0].length || 0;
+  let markerFrom = lineStart + leading;
+  let trimmed = line.slice(leading);
+  if (trimmed.startsWith("--")) return withTrimmedText("dash", line, lineStart, markerFrom, leading + 2);
+  if (trimmed.startsWith("#")) return withTrimmedText("hash", line, lineStart, markerFrom, leading + 1);
 }
-function parseTrailingComment(after) {
+function parseTrailingComment(after, afterStart) {
   let dashIdx = after.indexOf("--");
   let hashIdx = after.indexOf("#");
   let commentIdx = minNonNegative(dashIdx, hashIdx);
   if (commentIdx === -1) return void 0;
   let between2 = after.slice(0, commentIdx);
   if (!/^[\s,]*$/.test(between2)) return void 0;
-  if (hashIdx !== -1 && hashIdx === commentIdx) return { kind: "hash", text: after.slice(hashIdx + 1).trimStart() };
-  return { kind: "dash", text: after.slice(dashIdx + 2).trimStart() };
+  let markerFrom = afterStart + commentIdx;
+  if (hashIdx !== -1 && hashIdx === commentIdx) return withTrimmedText("hash", after, afterStart, markerFrom, hashIdx + 1);
+  return withTrimmedText("dash", after, afterStart, markerFrom, dashIdx + 2);
+}
+function withTrimmedText(kind, raw, rawFrom, markerFrom, textStart) {
+  let whitespace = raw.slice(textStart).match(/^\s*/)?.[0].length || 0;
+  return { kind, text: raw.slice(textStart + whitespace), from: rawFrom + textStart + whitespace, markerFrom };
 }
-function consumeComment(comment, metadata, descriptionLines) {
+function consumeComment(comment, metadata, descriptionLines, entries) {
   if (comment.kind === "hash") {
-    let cleaned = extractHashMetadata(comment.text, metadata);
+    let cleaned = extractHashMetadata(comment, metadata, entries);
     let trailingDescription = parseHashCommentDescription(cleaned);
     if (trailingDescription) descriptionLines.push(trailingDescription);
     return;
   }
   if (comment.text.startsWith("#")) return;
-  let description = extractMetadataPairs(comment.text, metadata);
+  let description = extractMetadataPairs(comment.text, comment.from, metadata, entries);
   if (description) descriptionLines.push(description);
 }
-function extractHashMetadata(text, metadata) {
+function extractHashMetadata(comment, metadata, entries) {
+  let text = comment.text;
   let cursor = skipWhitespace2(text, 0);
-  let pair = matchMetadataToken(text, cursor, false);
+  let pair = matchMetadataToken(text, cursor, false, comment.from, comment.markerFrom);
   if (!pair) return text.trim();
-  metadata[pair.key] = parseMetadataValue(pair.rawValue);
+  consumePair(pair, metadata, entries);
   cursor = pair.end;
   while (true) {
     let nextStart = skipWhitespace2(text, cursor);
     if (text[nextStart] !== "#") return text.slice(nextStart).trim();
-    let nextPair = matchMetadataToken(text, nextStart, true);
+    let nextPair = matchMetadataToken(text, nextStart, true, comment.from);
     if (!nextPair) return text.slice(nextStart).trim();
-    metadata[nextPair.key] = parseMetadataValue(nextPair.rawValue);
+    consumePair(nextPair, metadata, entries);
     cursor = nextPair.end;
   }
 }
-function extractMetadataPairs(text, metadata) {
-  let cleaned = text.replace(embeddedMetadataPair, (_match, leadingSpace, _hash, key, rawValue) => {
-    if (key) metadata[key] = parseMetadataValue(rawValue);
+function extractMetadataPairs(text, textFrom, metadata, entries) {
+  let cleaned = text.replace(embeddedMetadataPair, (match, leadingSpace, _hash, key, rawValue, offset2) => {
+    if (key) {
+      let hashStart = textFrom + offset2 + leadingSpace.length;
+      let valueOffset = rawValue ? match.indexOf(rawValue) : -1;
+      consumePair(
+        {
+          key,
+          rawValue,
+          keyFrom: hashStart + 1,
+          keyTo: hashStart + 1 + key.length,
+          from: hashStart,
+          to: hashStart + 1 + key.length,
+          valueFrom: valueOffset >= 0 ? textFrom + offset2 + valueOffset : void 0,
+          valueTo: valueOffset >= 0 ? textFrom + offset2 + valueOffset + rawValue.length : void 0,
+          end: offset2 + match.length
+        },
+        metadata,
+        entries
+      );
+    }
     return leadingSpace ? " " : "";
   });
   return cleaned.replace(/\s+/g, " ").trim();
 }
+function consumePair(pair, metadata, entries) {
+  let value = parseMetadataValue(pair.rawValue);
+  metadata[pair.key] = value;
+  entries.push({
+    key: pair.key,
+    value,
+    rawValue: pair.rawValue,
+    from: pair.from,
+    to: pair.to,
+    valueFrom: pair.valueFrom,
+    valueTo: pair.valueTo,
+    hasValue: pair.rawValue != null
+  });
+}
 function parseMetadataValue(rawValue) {
   if (!rawValue) return "true";
   if (!rawValue.startsWith('"')) return rawValue;
@@ -10546,21 +10642,24 @@ function parseHashCommentDescription(cleaned) {
   let description = cleaned.slice(2).trim();
   return description || void 0;
 }
-function matchMetadataToken(text, start, hasHashPrefix) {
+function matchMetadataToken(text, start, hasHashPrefix, textFrom, firstHashFrom) {
   let cursor = hasHashPrefix ? start + 1 : start;
   let keyStart = cursor;
   while (/[A-Za-z0-9_-]/.test(text[cursor] || "")) cursor++;
   if (cursor === keyStart) return void 0;
   let key = text.slice(keyStart, cursor);
+  let from2 = hasHashPrefix ? textFrom + start : firstHashFrom ?? textFrom + keyStart;
+  let keyFrom = textFrom + keyStart;
+  let keyTo = textFrom + cursor;
   let afterKey = skipWhitespace2(text, cursor);
   if (text[afterKey] === "=") {
     let valueStart = skipWhitespace2(text, afterKey + 1);
     let value = readMetadataValue(text, valueStart);
     if (!value) return void 0;
-    return { key, rawValue: value.rawValue, end: value.end };
+    return { key, rawValue: value.rawValue, keyFrom, keyTo, from: from2, to: keyTo, valueFrom: textFrom + valueStart, valueTo: textFrom + value.end, end: value.end };
   }
   if (afterKey >= text.length || text[afterKey] === "#" || text.startsWith("--", afterKey)) {
-    return { key, rawValue: void 0, end: afterKey };
+    return { key, rawValue: void 0, keyFrom, keyTo, from: from2, to: keyTo, end: afterKey };
   }
 }
 function readMetadataValue(text, start) {
@@ -10786,6 +10885,14 @@ var AnalysisSession = class {
     let suffix = scopeKey ? `:${scopeKey}` : "";
     return `${kind}:${location.file}:${location.from.offset}:${location.to.offset}${suffix}`;
   }
+  extractMetadata(node) {
+    let details = extractLeadingMetadataDetails(node);
+    let file = getFile(node);
+    for (let diagnostic of validateMetadataEntries(details.entries)) {
+      this.diagRange(file, diagnostic.from, diagnostic.to, diagnostic.message);
+    }
+    return details.metadata;
+  }
   renderTableHover(table2) {
     let desc2 = table2.metadata?.description ? `
 
@@ -10826,7 +10933,7 @@ ${field.metadata.description}` : "";
       let hasNamespace = name.includes(".");
       let tablePath = !hasNamespace && this.config.defaultNamespace ? `${this.config.defaultNamespace}.${name}` : name;
       let type = syntaxNode.getChild("QueryExpression") ? "view" : "table";
-      let table2 = { name, type, tablePath, filePath: fi.path, columns: [], joins: [], metadata: extractLeadingMetadata(syntaxNode), syntaxNode };
+      let table2 = { name, type, tablePath, filePath: fi.path, columns: [], joins: [], metadata: this.extractMetadata(syntaxNode), syntaxNode };
       Object.assign(table2, this.addSymbol("table", refNode, name, { hover: this.renderTableHover(table2) }));
       syntaxNode.getChildren("ColumnDef").forEach((node) => this.addColumn(table2, node));
       syntaxNode.getChildren("JoinDef").forEach((node) => this.addJoin(table2, node));
@@ -10850,7 +10957,7 @@ ${field.metadata.description}` : "";
     if (parsed.error) return this.diag(node, parsed.error);
     if (!parsed.type) return this.diag(node, `Unsupported data type: ${txt(node.getChild("DataType"))}`);
     let type = parsed.type;
-    let col = { name, type, metadata: extractLeadingMetadata(node) };
+    let col = { name, type, metadata: this.extractMetadata(node) };
     Object.assign(col, this.addSymbol("column", nameNode, name, { tableId: table2.symbolId, hover: this.renderFieldHover(table2, col) }));
     if (this.getField(name, table2)) return this.diag(node, `Table already has a field called "${name}"`);
     table2.columns.push(col);
@@ -10871,7 +10978,7 @@ ${field.metadata.description}` : "";
   addComputedColumn(table2, node) {
     let nameNode = node.getChild("Alias");
     let name = txt(nameNode);
-    let col = { name, type: scalarType("string"), exprNode: node.getChild("Expression"), metadata: extractLeadingMetadata(node) };
+    let col = { name, type: scalarType("string"), exprNode: node.getChild("Expression"), metadata: this.extractMetadata(node) };
     Object.assign(col, this.addSymbol("column", nameNode, name, { tableId: table2.symbolId, hover: this.renderFieldHover(table2, col) }));
     if (this.getField(name, table2)) return this.diag(node, `Table already has a field called "${name}"`);
     table2.columns.push(col);
@@ -11524,7 +11631,7 @@ ${field.metadata.description}` : "";
         return {
           sql: `EXTRACT(${unit} FROM ${expr.sql})`,
           type: scalarType("number"),
-          metadata: inferTemporalExtractionMetadata(unit, this.config.dialect),
+          metadata: inferTimeOrdinal(unit, this.config.dialect),
           isAgg: expr.isAgg,
           fanout: expr.fanout
         };
@@ -11620,11 +11727,11 @@ ${field.metadata.description}` : "";
   sameFieldMetadata(left2, right2) {
     if (!left2 && !right2) return true;
     if (!left2 || !right2) return false;
-    return left2.timeGrain == right2.timeGrain && left2.timePart == right2.timePart && left2.timeOrdinal == right2.timeOrdinal;
+    return left2.timeGrain == right2.timeGrain && left2.timeOrdinal == right2.timeOrdinal;
   }
   withoutTimeGrain(metadata) {
-    if (!metadata?.timeGrain && !metadata?.timePart && !metadata?.timeOrdinal) return metadata;
-    let { timeGrain: _timeGrain, timePart: _timePart, timeOrdinal: _timeOrdinal, defaultName: _defaultName, ...next } = metadata;
+    if (!metadata?.timeGrain && !metadata?.timeOrdinal) return metadata;
+    let { timeGrain: _timeGrain, timeOrdinal: _timeOrdinal, defaultName: _defaultName, ...next } = metadata;
     return Object.keys(next).length ? next : void 0;
   }
   isPercentileFunctionCall(node) {
@@ -11932,11 +12039,14 @@ ${field.metadata.description}` : "";
   }
   diag(node, message, defaultReturn) {
     let file = getFile(node);
-    let from2 = getPosition(node.from, file);
-    let to = getPosition(node.to, file);
-    this.diagnostics.push({ severity: "error", message, file: toRelativePath(file.path), from: from2, to, frame: buildFrame(from2, to) });
+    this.diagRange(file, node.from, node.to, message);
     return defaultReturn;
   }
+  diagRange(file, fromOffset, toOffset, message) {
+    let from2 = getPosition(fromOffset, file);
+    let to = getPosition(toOffset, file);
+    this.diagnostics.push({ severity: "error", message, file: toRelativePath(file.path), from: from2, to, frame: buildFrame(from2, to) });
+  }
   checkTypes(expr, expected, node) {
     if (isScalarType(expr.type, "error") || isScalarType(expr.type, "null")) return;
     if (expected.some((kind) => kind == "array" ? isArrayType(expr.type) : isScalarType(expr.type, kind))) return;
@@ -11990,7 +12100,7 @@ function replaceParams(sql, params) {
 
 // ../lang/core.ts
 async function loadWorkspace(dir, includeMd, ignoredFiles = []) {
-  let ignore = ["node_modules/**", "**/.*/**", ...ignoredFiles];
+  let ignore = ["node_modules/**", "**/.*/**", "**/agents.md", "**/claude.md", ...ignoredFiles];
   let paths = await glob(includeMd ? "**/*.{gsql,md}" : "**/*.gsql", { cwd: dir, ignore, follow: false, nocase: true });
   let files = [];
   for await (let file of paths) {
@@ -12527,7 +12637,7 @@ async function pathExists(filePath) {
 import { readFileSync } from "fs";
 async function getConnection() {
   if (config.dialect === "bigquery") {
-    let mod = await importConnection(() => import("./bigQuery-OQUNH3VT.js"), "@google-cloud/bigquery", "BigQuery");
+    let mod = await importConnection(() => import("./bigQuery-YIWXZPY6.js"), "@google-cloud/bigquery", "BigQuery");
     let options = {};
     if (process.env.GOOGLE_CREDENTIALS_CONTENT) {
       let parsed = JSON.parse(process.env.GOOGLE_CREDENTIALS_CONTENT);
@@ -12538,7 +12648,7 @@ async function getConnection() {
     }
     return new mod.BigQueryConnection(options);
   } else if (config.dialect === "duckdb") {
-    let mod = await importConnection(() => import("./duckdb-TKVMONRK.js"), "@duckdb/node-api", "DuckDB");
+    let mod = await importConnection(() => import("./duckdb-V6PJEA7H.js"), "@duckdb/node-api", "DuckDB");
     return new mod.DuckDBConnection({});
   } else if (config.dialect === "clickhouse") {
     let mod = await importConnection(() => import("./clickhouse-S3BJSKND.js"), "@clickhouse/client", "ClickHouse");
@@ -12554,7 +12664,7 @@ async function getConnection() {
       requestTimeout: config.clickhouse?.requestTimeout
     });
   } else if (config.dialect === "snowflake") {
-    let mod = await importConnection(() => import("./snowflake-3VPDEYYP.js"), "snowflake-sdk", "Snowflake");
+    let mod = await importConnection(() => import("./snowflake-HVSTYBLB.js"), "snowflake-sdk", "Snowflake");
     return new mod.SnowflakeConnection({
       privateKeyPath: process.env.SNOWFLAKE_PRI_KEY_PATH,
       privateKey: process.env.SNOWFLAKE_PRI_KEY,
@@ -12865,4 +12975,4 @@ export {
   runNamedQueryFromMd,
   runVitePlugin
 };
-//# sourceMappingURL=chunk-TZTTALAV.js.map
+//# sourceMappingURL=chunk-UTV3ERGI.js.map