@bitcobblers/wod-wiki-wql 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1956 @@
+'use strict';
+
+var lr = require('@lezer/lr');
+var language = require('@codemirror/language');
+var autocomplete = require('@codemirror/autocomplete');
+var highlight = require('@lezer/highlight');
+var wodWikiCore = require('@bitcobblers/wod-wiki-core');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/vocabulary.ts
+var WQL_METRIC_FAMILIES = ["reps", "distance", "resistance", "elapsed", "power", "pace"];
+var WQL_METRIC_AGGREGATES = ["totalVolume", "totalDistance", "tis", "sessionLoad"];
+var WQL_AGGREGATORS = ["sum", "avg", "min", "max", "count", "last", "delta"];
+var WQL_COMPARISON_OPS = [">", ">=", "<", "<=", "==", "!="];
+var WQL_TAG_KEYS = [
+  "effort",
+  "discipline",
+  "intensity",
+  "note",
+  "page",
+  "origin",
+  "grain",
+  "metric",
+  "block",
+  "result",
+  "tags"
+];
+var WQL_VIRTUAL_DIMS = ["day", "week", "session", "round"];
+var WQL_CALC_TARGETS = [
+  "calc.metMinutes",
+  "calc.acwr",
+  "calc.monotony",
+  "calc.strain",
+  "calc.e1rm",
+  "calc.ctl",
+  "calc.atl",
+  "calc.tsb",
+  // Wellness + capture metrics (seeds in seeds.ts): soreness/sleep/hrv are
+  // user-captured passthroughs; readiness is their composite; mvcBw is
+  // hang/%BW; ef is running pace ÷ HR; adherence is sessions ÷ planned;
+  // pct1rm is the Epley-inverse intensity; sends count climbing sends.
+  "calc.soreness",
+  "calc.sleep",
+  "calc.hrv",
+  "calc.readiness",
+  "calc.mvcBw",
+  "calc.ef",
+  "calc.adherence",
+  "calc.pct1rm",
+  "calc.sends"
+];
+var WQL_INTENSITY_TIERS = ["low", "moderate", "high"];
+var WQL_GRAINS = ["segment", "summary", "rollup"];
+var WQL_FIND_TARGETS = ["note", "block", "effort"];
+var WQL_SCOPES = ["journal", "collections", "feeds", "all"];
+var WQL_CONTENT_FILTER_KEYS = ["type", "text", "has", "source", "catalog", ...WQL_TAG_KEYS];
+var WQL_SOURCES = ["journal", "collections", "feeds", "notes", "blocks", "efforts", "metrics"];
+var WQL_ROLLUP_PERIODS = ["1d", "1w"];
+var WQL_DISPLAY_UNITS = ["kg", "lb"];
+var WQL_KEYWORDS = [
+  "find",
+  "rows",
+  "where",
+  "group",
+  "by",
+  "order",
+  "limit",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count",
+  "last",
+  "delta"
+];
+var parser = lr.LRParser.deserialize({
+  version: 14,
+  states: "(jOVQPOOOOQO'#C_'#C_O[QPO'#C^QaQQOOOlQPO,58xOqQPO'#CbO|QPO'#CjO!RQPO'#CmQOQPOOQ!WQPOOQ!]QQOOO!eQQO'#CaOOQO1G.d1G.dOOQO'#Ce'#CeO!vQPO'#CcO!{QPO'#CcOOQO,58|,58|O#QQPO,58|O#YQPO,59UO#bQQO,59XO#gQPO'#CpO#lQQO,58{O#}QPO,58}O$VQPO,58}O$[QPO'#CrO$dQPO1G.hOOQO1G.h1G.hOOQO'#Cl'#ClOOQO1G.p1G.pO$lQPO1G.pO$tQPO1G.sOOQO,59[,59[OOQO-E6n-E6nO$yQPO'#CgO%[QPO'#CgO%jQPO'#CfOOQO1G.i1G.iO#}QPO1G.iOOQO,59^,59^OOQO-E6p-E6pOOQO7+$S7+$SO%uQPO'#CsO%zQPO7+$[OOQO7+$[7+$[O&SQPO7+$_OOQO,59R,59RO&XQPO,59RO#}QPO'#CqO&^QPO,59QOOQO7+$T7+$TOOQO,59_,59_OOQO-E6q-E6qOOQO<<Gv<<GvOOQO<<Gy<<GyO&iQPO1G.mOOQO,59],59]OOQO-E6o-E6oOOQO7+$X7+$X",
+  stateData: "&w~OjOS~OSPO~OkSO~O_UObVOmTO~OSZO~OS]OW_Op`O~OmbO~OqcO~ObVO~O_UObVO~OldO_TXbTXhTXmTX~OkfO~OS]O~OohOpjO~OSkOplO~OcnO~OSoO~OldO_TabTahTamTa~OSqO]rO~OkuO~OS]OW_O~OohOpxO~OoyOp{O~OS|O~O[}Ok!OOnZXoZXpZX~O[}OnZXoZXpZX~On!POoYXpYX~OSkO~OoyOp!UO~Or!VO~OS!WO~On!POoYapYa~O[!ZOnZioZipZi~O",
+  goto: "#YhPPilPoruP{!S!YPP!aP!e!kPP!p!v!|#SRRORQOR[SRYRQaTRvhS^ThRg_QtfR!RuSsfuR!X!PTXRYQmbR!SyVWRXYQeZRpeQ!QsR!Y!QQiaRwiQzmR!Tz",
+  nodeNames: "\u26A0 Query Head Aggregator Word Metric Filters Filter Negate TagKey TagValue Value Star Quoted GroupBy By Dimension Rollup RollupDot Int",
+  maxTerm: 34,
+  skippedNodes: [0],
+  repeatNodeCount: 4,
+  tokenData: "'a~RfXY!gYZ!g]^!gpq!gqr!xrs!}xy#lyz#qz{#v|}#{}!O$Q!O!P$f!Q![%c![!]%y!c!}$Q#R#S$Q#T#U$Q#U#V&O#V#o$Q#o#p'Q#p#q'V#q#r'[~!lSj~XY!gYZ!g]^!gpq!g~!}OW~~#QTOr!}rs#as;'S!};'S;=`#f<%lO!}~#fO]~~#iP;=`<%l!}~#qOq~~#vOr~~#{O[~~$QOo~P$VTSP}!O$Q!Q![$Q!c!}$Q#R#S$Q#T#o$Q~$kPl~#f#g$n~$qP#c#d$t~$wP#`#a$z~$}P#`#a%Q~%TP#i#j%W~%ZP#d#e%^~%cOb~R%jTcQSP}!O$Q!Q![%c!c!}$Q#R#S$Q#T#o$Q~&OOk~R&TVSP}!O$Q!Q![$Q!c!}$Q#R#S$Q#T#m$Q#m#n&j#n#o$QR&qT_QSP}!O$Q!Q![$Q!c!}$Q#R#S$Q#T#o$Q~'VOm~~'[On~~'aOp~",
+  tokenizers: [0, 1],
+  topRules: { "Query": [0, 1] },
+  tokenPrec: 0
+});
+
+// src/grammar/wql.parser.terms.ts
+var wql_parser_terms_exports = {};
+__export(wql_parser_terms_exports, {
+  Aggregator: () => Aggregator,
+  By: () => By,
+  Dimension: () => Dimension,
+  Filter: () => Filter,
+  Filters: () => Filters,
+  GroupBy: () => GroupBy,
+  Head: () => Head,
+  Int: () => Int,
+  Metric: () => Metric,
+  Negate: () => Negate,
+  Query: () => Query,
+  Quoted: () => Quoted,
+  Rollup: () => Rollup,
+  RollupDot: () => RollupDot,
+  Star: () => Star,
+  TagKey: () => TagKey,
+  TagValue: () => TagValue,
+  Value: () => Value,
+  Word: () => Word
+});
+var Query = 1;
+var Head = 2;
+var Aggregator = 3;
+var Word = 4;
+var Metric = 5;
+var Filters = 6;
+var Filter = 7;
+var Negate = 8;
+var TagKey = 9;
+var TagValue = 10;
+var Value = 11;
+var Star = 12;
+var Quoted = 13;
+var GroupBy = 14;
+var By = 15;
+var Dimension = 16;
+var Rollup = 17;
+var RollupDot = 18;
+var Int = 19;
+
+// src/wqlSuffix.ts
+function splitAtWhere(text) {
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "{") depth++;
+    else if (c === "}") depth = Math.max(0, depth - 1);
+    else if (depth === 0 && c === "w" && text.slice(i, i + 5) === "where" && (i === 0 || /\s/.test(text[i - 1])) && (i + 5 >= text.length || /\s/.test(text[i + 5]))) {
+      return { primary: text.slice(0, i).trim(), where: text.slice(i + 5).trim() };
+    }
+  }
+  return { primary: text.trim() };
+}
+var DISPLAY_UNIT_RE = /\s+in\s+([a-zA-Z0-9_-]+)\s*$/;
+var ROLLUP_RE = /\.rollup\((\d+)?([a-zA-Z]*)\)\s*$/;
+var BY_RE = /\s+by\s+\{([^}]*)\}\s*$/;
+var LAST_RE = /\s+last\s+(\d+)([dw])\s*$/i;
+var IN_SCOPE_RE = /\s+in\s+(\w+)\s*$/;
+function parseWqlSuffixes(raw) {
+  const { primary, where } = splitAtWhere(raw);
+  let text = primary.trim();
+  let displayUnit;
+  let rollup;
+  let groupBy;
+  let last;
+  let scope;
+  const isFind = text.startsWith("find:");
+  const isRows = /^rows(?=[:{]|\s|$)/.test(text);
+  if (isFind || isRows) {
+    const lastMatch = LAST_RE.exec(text);
+    if (lastMatch) {
+      last = {
+        size: parseInt(lastMatch[1], 10),
+        unit: lastMatch[2].toLowerCase(),
+        raw: lastMatch[0].trim()
+      };
+      text = text.slice(0, lastMatch.index).trim();
+    }
+    if (isFind) {
+      const scopeMatch = IN_SCOPE_RE.exec(text);
+      if (scopeMatch) {
+        scope = scopeMatch[1];
+        text = text.slice(0, scopeMatch.index).trim();
+      }
+    } else {
+      const rollupMatch = ROLLUP_RE.exec(text);
+      if (rollupMatch) {
+        const rawRollup = rollupMatch[1] + rollupMatch[2];
+        rollup = { size: rollupMatch[1] ? parseInt(rollupMatch[1], 10) : 1, unit: rollupMatch[2] || "", raw: rawRollup };
+        text = text.slice(0, rollupMatch.index).trim();
+      }
+      const byMatch = BY_RE.exec(text);
+      if (byMatch) {
+        groupBy = byMatch[1].split(",").map((d) => d.trim()).filter(Boolean);
+        text = text.slice(0, byMatch.index).trim();
+      }
+    }
+  } else {
+    const unitMatch = DISPLAY_UNIT_RE.exec(text);
+    if (unitMatch) {
+      displayUnit = unitMatch[1];
+      text = text.slice(0, unitMatch.index).trim();
+    }
+    const rollupMatch = ROLLUP_RE.exec(text);
+    if (rollupMatch) {
+      const rawRollup = rollupMatch[1] + rollupMatch[2];
+      const size = rollupMatch[1] ? parseInt(rollupMatch[1], 10) : 1;
+      const unit = rollupMatch[2] || "";
+      rollup = { size, unit, raw: rawRollup };
+      text = text.slice(0, rollupMatch.index).trim();
+    }
+    const byMatch = BY_RE.exec(text);
+    if (byMatch) {
+      groupBy = byMatch[1].split(",").map((d) => d.trim()).filter(Boolean);
+      text = text.slice(0, byMatch.index).trim();
+    }
+  }
+  return {
+    where,
+    displayUnit,
+    rollup,
+    groupBy,
+    last,
+    scope,
+    primaryText: text
+  };
+}
+
+// src/wql.ts
+function isFindQuery(parsed) {
+  return "target" in parsed;
+}
+function isRowsQuery(parsed) {
+  return parsed.family === "rows";
+}
+var AGGS = WQL_AGGREGATORS;
+function cannotParse(text) {
+  return `Cannot parse "${text}". Expected agg:metric{filters} by {dims} .rollup(period)`;
+}
+var CMP_RE = /^(.+?)\s*(>=|<=|!=|==|>|<)\s*(-?\d+(?:\.\d+)?)\s*$/;
+function cannotParseJoin(text) {
+  return `Cannot parse join "${text}". Expected find:target{filters} or agg:metric{filters} <op> <number>`;
+}
+function parseJoinClause(where) {
+  if (where.trimStart().startsWith("find:")) {
+    const fp = parseFindQuery(where);
+    if (fp.error) return { error: fp.error };
+    return { find: { target: fp.target, filters: fp.filters, scope: fp.scope, last: fp.last } };
+  }
+  const m = CMP_RE.exec(where.trim());
+  if (!m) return { error: cannotParseJoin(where) };
+  const head = parseAnalyticsQuery(m[1].trim());
+  if (head.error) return { error: head.error };
+  return {
+    metric: {
+      agg: head.agg,
+      metric: head.metric,
+      filters: head.filters,
+      operator: m[2],
+      threshold: parseFloat(m[3])
+    }
+  };
+}
+function parseQuery(raw) {
+  const trimmed = raw.trimStart();
+  if (trimmed.startsWith("find:")) {
+    return parseFindQuery(raw);
+  }
+  if (/^rows(?=[:{]|\s|$)/.test(trimmed)) {
+    return parseRowsQuery(raw);
+  }
+  return parseAnalyticsQuery(raw);
+}
+function cannotParseRows(text) {
+  return `Cannot parse "${text}". Expected rows:{result:\u2026|block:\u2026|note:\u2026} or rows:segment{\u2026} last 8w`;
+}
+function parseRowsQuery(raw) {
+  const suffixes = parseWqlSuffixes(raw);
+  const { where: whereText, last, groupBy, rollup, primaryText } = suffixes;
+  const result = {
+    raw,
+    family: "rows",
+    filters: [],
+    last: last ? { size: last.size, unit: last.unit } : void 0
+  };
+  if (whereText || groupBy || rollup) {
+    result.error = `Rows queries return raw statements \u2014 no where / by / rollup. Got "${primaryText.trim()}"`;
+    return result;
+  }
+  const text = primaryText.trim();
+  const brace = text.indexOf("{");
+  const head = (brace === -1 ? text : text.slice(0, brace)).trim();
+  const filterText = brace === -1 ? "" : text.slice(brace).trim();
+  if (head === "rows" || head === "rows:") ; else if (head.startsWith("rows:")) {
+    const target = head.slice("rows:".length).trim();
+    if (!target || /\s/.test(target)) {
+      result.error = cannotParseRows(text);
+      return result;
+    }
+    result.outputType = target;
+  } else {
+    result.error = cannotParseRows(text);
+    return result;
+  }
+  if (filterText) {
+    if (!/^\{.*\}$/.test(filterText)) {
+      result.error = cannotParseRows(text);
+      return result;
+    }
+    const synthetic = `find:_${filterText}`;
+    const tree = parser.parse(synthetic);
+    let syntaxError = false;
+    tree.iterate({ enter(node) {
+      if (node.type.isError) syntaxError = true;
+    } });
+    if (syntaxError) {
+      result.error = cannotParseRows(text);
+      return result;
+    }
+    result.filters = extractFilters(tree.topNode, synthetic);
+  }
+  return result;
+}
+function extractFilters(query, text) {
+  const out = [];
+  const filters = query.getChild(Filters);
+  if (!filters) return out;
+  for (const filter of filters.getChildren(Filter)) {
+    const keyNode = filter.getChild(TagKey);
+    const valueNode = filter.getChild(TagValue);
+    if (!keyNode || !valueNode) continue;
+    const values = [];
+    for (const valueChild of valueNode.getChildren(Value)) {
+      const raw = text.slice(valueChild.from, valueChild.to);
+      const quoted = valueChild.getChild(Quoted) !== null;
+      let value = quoted ? raw.slice(1, -1) : raw;
+      const wildcard = quoted ? false : value.endsWith("*");
+      if (wildcard) value = value.slice(0, -1);
+      if (!value) continue;
+      values.push({ value, wildcard });
+    }
+    if (values.length === 0) continue;
+    out.push({
+      key: text.slice(keyNode.from, keyNode.to),
+      negate: filter.getChild(Negate) !== null,
+      values
+    });
+  }
+  return out;
+}
+function parseAnalyticsQuery(raw) {
+  const suffixes = parseWqlSuffixes(raw);
+  const { where: whereText, displayUnit, groupBy, rollup, primaryText: text } = suffixes;
+  const base = {
+    raw,
+    agg: "sum",
+    metric: "",
+    filters: [],
+    groupBy: groupBy ?? [],
+    displayUnit,
+    rollup: rollup ? { size: rollup.size, unit: rollup.unit } : void 0
+  };
+  if (rollup && rollup.unit !== "d" && rollup.unit !== "w") {
+    base.error = cannotParse(text);
+    return base;
+  }
+  const tree = parser.parse(text);
+  let syntaxError = false;
+  tree.iterate({ enter(node) {
+    if (node.type.isError) syntaxError = true;
+  } });
+  if (syntaxError) {
+    base.error = cannotParse(text);
+    return base;
+  }
+  const query = tree.topNode;
+  const head = query.getChild(Head);
+  const aggNode = head?.getChild(Aggregator);
+  const metricNode = head?.getChild(Metric);
+  if (!head || !aggNode || !metricNode) {
+    base.error = cannotParse(text);
+    return base;
+  }
+  const aggText = text.slice(aggNode.from, aggNode.to);
+  if (!AGGS.includes(aggText)) {
+    base.error = `Unknown aggregator "${aggText}". Try: ${AGGS.join(", ")}`;
+    return base;
+  }
+  base.agg = aggText;
+  base.metric = text.slice(metricNode.from, metricNode.to);
+  base.filters = extractFilters(query, text);
+  if (whereText) {
+    const join = parseJoinClause(whereText);
+    if (join.error) {
+      base.error = join.error;
+      return base;
+    }
+    if (!join.find) {
+      base.error = `Cross-store join on an analytics query must be find:\u2026, got "${whereText}"`;
+      return base;
+    }
+    base.join = join.find;
+  }
+  return base;
+}
+function cannotParseFind(text) {
+  return `Cannot parse "${text}". Expected find:target{filters} in scope last 8w`;
+}
+function parseFindQuery(raw) {
+  const suffixes = parseWqlSuffixes(raw);
+  const { where: whereText, last, scope, primaryText: text } = suffixes;
+  const result = {
+    raw,
+    target: "",
+    filters: [],
+    scope,
+    last: last ? { size: last.size, unit: last.unit } : void 0
+  };
+  const tree = parser.parse(text);
+  let syntaxError = false;
+  tree.iterate({ enter(node) {
+    if (node.type.isError) syntaxError = true;
+  } });
+  if (syntaxError) {
+    result.error = cannotParseFind(text);
+    return result;
+  }
+  const query = tree.topNode;
+  const head = query.getChild(Head);
+  const aggNode = head?.getChild(Aggregator);
+  const metricNode = head?.getChild(Metric);
+  if (!head || !aggNode || !metricNode) {
+    result.error = cannotParseFind(text);
+    return result;
+  }
+  const aggText = text.slice(aggNode.from, aggNode.to);
+  if (aggText !== "find") {
+    result.error = `Expected "find:" but got "${aggText}:"`;
+    return result;
+  }
+  result.target = text.slice(metricNode.from, metricNode.to);
+  result.filters = extractFilters(query, text);
+  if (whereText) {
+    const join = parseJoinClause(whereText);
+    if (join.error) {
+      result.error = join.error;
+      return result;
+    }
+    if (!join.metric) {
+      result.error = `Cross-store join on a find query must be agg:metric{} <op> <number>, got "${whereText}"`;
+      return result;
+    }
+    result.join = join.metric;
+  }
+  return result;
+}
+
+// src/disciplines.ts
+var EFFORT_DISCIPLINES = [
+  "bodyweight",
+  "cycling",
+  "gymnastics",
+  "kettlebell",
+  "recovery",
+  "rowing",
+  "running",
+  "strength",
+  "swimming",
+  "walking"
+];
+function isEffortDiscipline(value) {
+  return typeof value === "string" && EFFORT_DISCIPLINES.includes(value.toLowerCase());
+}
+var DISCIPLINE_FACTORS = {
+  strength: 1.2,
+  kettlebell: 1.2,
+  gymnastics: 1.2,
+  recovery: 0.9,
+  bodyweight: 1,
+  cycling: 1,
+  rowing: 1,
+  running: 1,
+  swimming: 1,
+  walking: 1
+};
+function disciplineFactorFor(discipline) {
+  if (!discipline) return 1;
+  const key = discipline.toLowerCase();
+  return isEffortDiscipline(key) ? DISCIPLINE_FACTORS[key] : 1;
+}
+var wqlLanguage = language.LRLanguage.define({
+  parser: parser.configure({
+    props: [
+      highlight.styleTags({
+        // Rule styles color stray punctuation; the Word tokens inside carry
+        // the visible styling (unstyled children reset the parent class).
+        Aggregator: highlight.tags.keyword,
+        "Aggregator/Word": highlight.tags.keyword,
+        Metric: highlight.tags.variableName,
+        "Metric/Word": highlight.tags.variableName,
+        TagKey: highlight.tags.propertyName,
+        "TagKey/Word": highlight.tags.propertyName,
+        TagValue: highlight.tags.string,
+        "TagValue/Value/Word": highlight.tags.string,
+        "TagValue/Word": highlight.tags.string,
+        Negate: highlight.tags.operator,
+        Star: highlight.tags.operator,
+        Dimension: highlight.tags.attributeName,
+        "Dimension/Word": highlight.tags.attributeName,
+        By: highlight.tags.keyword,
+        RollupDot: highlight.tags.keyword,
+        Int: highlight.tags.number,
+        "Rollup/Word": highlight.tags.unit,
+        braceOpen: highlight.tags.bracket,
+        braceClose: highlight.tags.bracket,
+        parenOpen: highlight.tags.bracket,
+        parenClose: highlight.tags.bracket,
+        colon: highlight.tags.punctuation,
+        comma: highlight.tags.punctuation,
+        pipe: highlight.tags.punctuation,
+        dot: highlight.tags.punctuation
+      })
+    ]
+  }),
+  languageData: {
+    closeBrackets: { brackets: ["{", "("] }
+  }
+});
+function ancestor(node, ...names) {
+  for (let n = node; n; n = n.parent) {
+    if (names.includes(n.name)) return n;
+  }
+  return null;
+}
+function options(labels) {
+  return labels.map((label) => typeof label === "string" ? { label } : label);
+}
+function wqlCompletionSource(options_ = {}) {
+  const { effortNames } = options_;
+  const metricOptions = () => {
+    const efforts = effortNames?.() ?? [];
+    return [
+      ...options(WQL_METRIC_AGGREGATES).map((c) => ({ ...c, type: "constant" })),
+      ...options(WQL_METRIC_FAMILIES).map((c) => ({ ...c, type: "variable" })),
+      ...options(efforts.flatMap((slug) => WQL_METRIC_FAMILIES.map((family) => `${slug}.${family}`))).map((c) => ({ ...c, type: "variable" })),
+      ...options(WQL_CALC_TARGETS).map((c) => ({ ...c, type: "namespace" })),
+      autocomplete.snippetCompletion("calc.${target}", { label: "calc.", detail: "calculated target", type: "namespace" })
+    ];
+  };
+  const tagValueOptions = (key) => {
+    switch (key) {
+      case "effort":
+        return options(effortNames?.() ?? []);
+      case "discipline":
+        return options(EFFORT_DISCIPLINES);
+      case "intensity":
+        return options(WQL_INTENSITY_TIERS);
+      case "grain":
+        return options(WQL_GRAINS);
+      case "metric":
+        return metricOptions();
+      default:
+        return null;
+    }
+  };
+  function source(context) {
+    const word = context.matchBefore(/[\w.*-]*/);
+    if (!word || word.from === word.to && !context.explicit) return null;
+    const tree = language.syntaxTree(context.state);
+    const node = tree.resolveInner(context.pos, -1);
+    const filter = ancestor(node, "Filter");
+    if (filter) {
+      const filterText = context.state.sliceDoc(filter.from, context.pos);
+      const colonIndex = filterText.indexOf(":");
+      if (colonIndex === -1) {
+        const keyWord = context.matchBefore(/[\w-]*/);
+        return { from: keyWord.from, options: options(WQL_TAG_KEYS).map((c) => ({ ...c, type: "property" })), validFor: /^[\w-]*$/ };
+      }
+      const key = filterText.slice(0, colonIndex).replace(/^!/, "").trim();
+      const valueOptions = tagValueOptions(key);
+      if (!valueOptions) return null;
+      return { from: word.from, options: valueOptions, validFor: /^[\w*-]*$/ };
+    }
+    if (ancestor(node, "Filters")) {
+      const keyWord = context.matchBefore(/[\w-]*/);
+      return { from: keyWord.from, options: options(WQL_TAG_KEYS).map((c) => ({ ...c, type: "property" })), validFor: /^[\w-]*$/ };
+    }
+    if (ancestor(node, "GroupBy")) {
+      const dimWord = context.matchBefore(/[\w-]*/);
+      return {
+        from: dimWord.from,
+        options: [
+          ...options(WQL_VIRTUAL_DIMS).map((c) => ({ ...c, type: "atom" })),
+          ...options(WQL_TAG_KEYS).map((c) => ({ ...c, type: "property" }))
+        ],
+        validFor: /^[\w-]*$/
+      };
+    }
+    const head = tree.topNode.getChild("Head");
+    const insideHead = ancestor(node, "Head") !== null;
+    const inMetric = node.name === "Metric" || node.name === "Word" && node.parent?.name === "Metric";
+    if (inMetric) {
+      return { from: word.from, options: metricOptions(), validFor: /^[\w.-]*$/ };
+    }
+    if (insideHead && head) {
+      const afterColon = context.state.sliceDoc(head.from, context.pos).includes(":");
+      const metricWord = head.getChild("Metric")?.getChild("Word");
+      const typedPastMetric = metricWord !== null && metricWord !== void 0 && /\s/.test(context.state.sliceDoc(metricWord.to, context.pos));
+      if (afterColon && !typedPastMetric) {
+        return { from: word.from, options: metricOptions(), validFor: /^[\w.-]*$/ };
+      }
+      if (!afterColon) {
+        return { from: word.from, options: options(WQL_AGGREGATORS).map((c) => ({ ...c, type: "keyword" })), validFor: /^[\w-]*$/ };
+      }
+    }
+    if (ancestor(node, "Rollup")) {
+      return {
+        from: word.from,
+        options: options(WQL_ROLLUP_PERIODS).map((c) => ({ ...c, type: "constant" })),
+        validFor: /^[\w]*$/
+      };
+    }
+    if (!head) {
+      return { from: word.from, options: options(WQL_AGGREGATORS).map((c) => ({ ...c, type: "keyword" })), validFor: /^[\w-]*$/ };
+    }
+    return {
+      from: word.from,
+      options: [
+        autocomplete.snippetCompletion("by {${dimension}}", { label: "by {}", detail: "group by dimensions", type: "keyword" }),
+        autocomplete.snippetCompletion(".rollup(${1}${d|w})", { label: ".rollup()", detail: "bucket period", type: "keyword" })
+      ],
+      validFor: /^[\w.-]*$/
+    };
+  }
+  return source;
+}
+function wqlCompletion(options2) {
+  return autocomplete.autocompletion({ override: [wqlCompletionSource(options2)] });
+}
+var wqlHighlightStyle = language.HighlightStyle.define([
+  { tag: highlight.tags.keyword, color: "hsl(var(--primary))" },
+  { tag: highlight.tags.variableName, color: "hsl(var(--accent-foreground))", fontWeight: "600" },
+  { tag: highlight.tags.propertyName, color: "hsl(var(--secondary-foreground))" },
+  { tag: highlight.tags.string, color: "hsl(var(--success))" },
+  { tag: highlight.tags.attributeName, color: "hsl(var(--warning))" },
+  { tag: highlight.tags.number, color: "hsl(var(--primary))" },
+  { tag: highlight.tags.unit, color: "hsl(var(--muted-foreground))" },
+  { tag: highlight.tags.operator, color: "hsl(var(--destructive))" },
+  { tag: [highlight.tags.bracket, highlight.tags.punctuation], color: "hsl(var(--muted-foreground))" }
+]);
+function wql(completionOptions) {
+  return new language.LanguageSupport(wqlLanguage, [
+    wqlCompletion(completionOptions),
+    language.syntaxHighlighting(wqlHighlightStyle)
+  ]);
+}
+
+// src/units.ts
+var KG_PER_LB = 0.45359237;
+var UNIT_FAMILIES = {
+  mass: {
+    base: "kg",
+    units: {
+      kg: 1,
+      lb: KG_PER_LB
+    }
+  },
+  distance: {
+    base: "m",
+    units: {
+      m: 1,
+      km: 1e3
+    }
+  }
+};
+function getUnitFamily(unit) {
+  if (!unit) return void 0;
+  for (const [family, def] of Object.entries(UNIT_FAMILIES)) {
+    if (def.units[unit] !== void 0) return family;
+  }
+  return void 0;
+}
+function convert(value, from, to) {
+  if (from === to || from === void 0 || to === void 0) return value;
+  const family = getUnitFamily(from);
+  if (!family || family !== getUnitFamily(to)) return value;
+  const def = UNIT_FAMILIES[family];
+  const fromFactor = def.units[from];
+  const toFactor = def.units[to];
+  if (fromFactor === void 0 || toFactor === void 0) return value;
+  return value * fromFactor / toFactor;
+}
+function resolveDisplayUnit(facts, {
+  directive,
+  preferred
+}) {
+  const sourceUnits = facts.map((row) => row.unit ?? row.metricUnit).filter((u) => Boolean(u));
+  const firstSource = sourceUnits[0];
+  if (directive) {
+    const directiveFamily = getUnitFamily(directive);
+    const applicable = directiveFamily !== void 0 && sourceUnits.some((u) => getUnitFamily(u) === directiveFamily);
+    return { unit: directive, convert: applicable };
+  }
+  if (preferred) {
+    const preferredFamily = getUnitFamily(preferred);
+    if (preferredFamily && sourceUnits.some((u) => getUnitFamily(u) === preferredFamily)) {
+      return { unit: preferred, convert: true };
+    }
+  }
+  return { unit: firstSource, convert: false };
+}
+function resolveCanonicalMetricKey(projectionName) {
+  const words = projectionName.trim().split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  return words.map(
+    (word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1)
+  ).join("");
+}
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readGroupTags(metadata) {
+  const tags = metadata?.groupTags;
+  if (!tags || typeof tags !== "object") return void 0;
+  const entries = Object.entries(tags).filter((pair) => typeof pair[1] === "string" && pair[1].length > 0).sort(([a], [b]) => a < b ? -1 : 1);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeSummaryFacts(logs, identity) {
+  const now = Date.now();
+  const rowsByKey = /* @__PURE__ */ new Map();
+  for (const output of logs) {
+    if (output.outputType !== "analytics") continue;
+    const label = output.metrics.find((m) => m.type === wodWikiCore.MetricType.Label);
+    const value = output.metrics.find((m) => m.type !== wodWikiCore.MetricType.Label && typeof m.value === "number");
+    if (!label || !value) continue;
+    const projectionName = String(label.value ?? label.image ?? "");
+    if (!projectionName) continue;
+    const metricKey = metadataString(value.metadata, "canonicalKey") ?? resolveCanonicalMetricKey(projectionName);
+    const effortSlug = metadataString(value.metadata, "effortSlug");
+    const discipline = metadataString(value.metadata, "effortDiscipline");
+    const intensityTier = metadataString(value.metadata, "effortIntensityTier");
+    const grade = metadataString(value.metadata, "grade");
+    const groupTags = readGroupTags(value.metadata) ?? (effortSlug ? { effort: effortSlug } : void 0);
+    const rowKey = groupTags ? `${metricKey}:${Object.entries(groupTags).map(([k, v]) => `${k}=${v}`).join(":")}` : metricKey;
+    rowsByKey.set(rowKey, {
+      id: `${identity.resultId}-${rowKey}-${now}`,
+      noteId: identity.noteId,
+      blockContentId: identity.blockContentId,
+      origin: identity.origin,
+      pageId: identity.pageId,
+      grain: "summary",
+      segmentId: identity.segmentId ?? "",
+      segmentVersion: identity.segmentVersion ?? 0,
+      resultId: identity.resultId,
+      type: metricKey,
+      value: value.value,
+      unit: value.unit,
+      label: projectionName,
+      metricKey,
+      metricLabel: projectionName,
+      metricUnit: value.unit,
+      ...effortSlug ? { effortSlug } : {},
+      ...discipline ? { discipline } : {},
+      ...intensityTier ? { intensityTier } : {},
+      ...grade ? { grade } : {},
+      timestamp: identity.workoutTimestamp ?? output.timeSpan?.started ?? now,
+      createdAt: now
+    });
+  }
+  return Array.from(rowsByKey.values());
+}
+
+// src/dashboard/frontmatter.ts
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner
+  );
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  return { meta: parseMetaLines(match[1].split(/\r?\n/)), body: raw.slice(match[0].length) };
+}
+function parseMetaLines(lines) {
+  const meta = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(itemMatch[1].trim());
+        i++;
+      }
+      meta[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num = Number(value);
+      meta[key] = !wasQuoted && value !== "" && !isNaN(num) ? num : value;
+    }
+  }
+  return meta;
+}
+function parseFrontmatterBody(innerContent) {
+  return parseMetaLines(innerContent.split(/\r?\n/));
+}
+function quoteYamlScalar(value) {
+  if (value === "") return '""';
+  const looksNumeric = !isNaN(Number(value));
+  const looksKeyword = /^(true|false|null|yes|no|on|off)$/i.test(value);
+  if (/[":'\n#{}[\\],&*?|<>=%!@`]/.test(value) || value !== value.trim() || value.startsWith("-") || looksNumeric || looksKeyword) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function serializeFrontmatter(meta) {
+  const lines = [];
+  for (const [key, value] of Object.entries(meta)) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        lines.push(`${key}: ""`);
+        continue;
+      }
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${quoteYamlScalar(item)}`);
+      }
+    } else if (typeof value === "number") {
+      lines.push(`${key}: ${value}`);
+    } else {
+      lines.push(`${key}: ${quoteYamlScalar(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function stripFrontmatter(raw) {
+  return parseFrontmatter(raw).body;
+}
+function getScalar(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getList(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value : [];
+}
+function parseFrontmatterCategories(raw) {
+  return getList(parseFrontmatter(raw).meta, "category").map((c) => c.toLowerCase());
+}
+function extractFrontmatterTags(raw) {
+  const meta = FRONTMATTER_RE.test(raw) ? parseFrontmatter(raw).meta : parseFrontmatterBody(raw);
+  const tags = meta["tags"];
+  const list = Array.isArray(tags) ? tags : typeof tags === "string" && tags.trim() ? tags.trim().startsWith("[") && tags.trim().endsWith("]") ? tags.trim().slice(1, -1).split(",") : [tags] : [];
+  return [...new Set(list.map((tag) => tag.trim()).filter(Boolean))];
+}
+function parseFlatProperties(innerContent) {
+  const props = {};
+  for (const line of innerContent.split(/\r?\n/)) {
+    const match = line.match(/^([^:]+):\s*(.*)$/);
+    if (match) {
+      props[match[1].trim()] = match[2].trim();
+    }
+  }
+  return props;
+}
+function parseFrontmatterProps(lines) {
+  const props = {};
+  for (const line of lines) {
+    const match = line.match(/^([^:]+):\s*(.*)$/);
+    if (match) {
+      props[match[1].trim()] = match[2].trim();
+    }
+  }
+  return props;
+}
+
+// src/static.ts
+function staticNotesFromBlocks(blocks) {
+  const map = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (!map.has(block.noteId)) {
+      map.set(block.noteId, {
+        id: block.noteId,
+        title: block.noteTitle,
+        createdAt: block.createdAt,
+        type: "note",
+        sourceId: block.sourceId,
+        catalog: (block.noteId.startsWith("feeds/") ? block.noteId.slice("feeds/".length) : block.noteId).split("/")[0]
+      });
+    }
+  }
+  return Array.from(map.values());
+}
+function staticTagIndexFromBlocks(blocks) {
+  const index = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.dataType !== "frontmatter") continue;
+    for (const tag of extractFrontmatterTags(block.rawContent)) {
+      const ids = index.get(tag);
+      if (ids) ids.add(block.noteId);
+      else index.set(tag, /* @__PURE__ */ new Set([block.noteId]));
+    }
+  }
+  return index;
+}
+
+// src/QueryService.ts
+var DAY = 864e5;
+function localDateString(ts) {
+  return new Date(ts).toLocaleDateString(void 0, { year: "numeric", month: "short", day: "numeric" });
+}
+function catalogOfItem(item) {
+  if (item.catalog) return item.catalog;
+  const raw = item.sourceId ? item.sourceId.replace(/^(collection|feed):/, "") : item.noteId || item.id || "";
+  if (!raw) return void 0;
+  const clean = raw.startsWith("feeds/") ? raw.slice("feeds/".length) : raw;
+  return clean.split("/")[0];
+}
+function sourceMatches(sourceId, kind) {
+  if (kind === "journal") return !sourceId || sourceId === "journal";
+  if (kind === "collection" || kind === "feed") {
+    return !!sourceId && sourceId.startsWith(`${kind}:`);
+  }
+  return sourceId === kind;
+}
+function applySourceFilter(items, filters) {
+  for (const filter of filters) {
+    if (filter.key !== "source") continue;
+    const wants = filter.values.map((v) => v.value);
+    items = items.filter((item) => {
+      const match = wants.some((w) => sourceMatches(item.sourceId, w));
+      return filter.negate ? !match : match;
+    });
+  }
+  return items;
+}
+function effectiveTimeWindow(createdAt, last, range, anchorNow) {
+  if (range) return createdAt >= range.start && createdAt <= range.end;
+  if (last) {
+    const cutoff = (anchorNow ?? Date.now()) - last.size * (last.unit === "w" ? 7 : 1) * DAY;
+    return createdAt >= cutoff;
+  }
+  return true;
+}
+function latestActivity(rows) {
+  let max = 0;
+  for (const r of rows) if (r.createdAt > max) max = r.createdAt;
+  return max;
+}
+function windowAnchor(selected, parsed, options2) {
+  if (options2.anchorNow !== void 0) return options2.anchorNow;
+  if (options2.anchor === "latest-activity" && parsed.last) return latestActivity(selected);
+  return void 0;
+}
+var defaultFactStore = {
+  getFactsByMetric: async () => [],
+  getFactsByTimeRange: async () => [],
+  getNoteTagLabels: async () => []
+};
+var defaultNoteStore = {
+  getAllNotes: async () => [],
+  getNoteIdsForTag: async () => /* @__PURE__ */ new Set()
+};
+var defaultBlockStore = {
+  getAllBlocks: async () => []
+};
+var defaultResultStore = {
+  getResultsByContentId: async () => [],
+  getResultById: async () => void 0,
+  getResultsForNote: async () => []
+};
+var defaultEffortStore = {
+  getAllEfforts: async () => []
+};
+function factTagValue(row, key, noteTags) {
+  switch (key) {
+    case "effort":
+      return row.effortSlug;
+    case "discipline":
+      return row.discipline;
+    case "grade":
+      return row.grade;
+    case "intensity":
+      return row.intensityTier;
+    case "note":
+      return row.noteId;
+    case "page":
+      return row.pageId;
+    case "origin":
+      return row.origin;
+    case "grain":
+      return row.grain;
+    case "metric":
+      return row.metricKey;
+    case "block":
+      return row.blockContentId;
+    case "result":
+      return row.resultId;
+    case "tags":
+      return noteTags.get(row.noteId) ?? [];
+    default:
+      return void 0;
+  }
+}
+function matchesFilters(row, filters, noteTags) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of filters) {
+    const groupKey = `${f.negate ? "!" : ""}${f.key}`;
+    const bucket = groups.get(groupKey);
+    if (bucket) bucket.push(f);
+    else groups.set(groupKey, [f]);
+  }
+  return [...groups.values()].every((group) => {
+    const key = group[0].key;
+    const negate = group[0].negate;
+    const raw = factTagValue(row, key, noteTags);
+    const rowValues = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+    const hit = group.some(
+      (f) => f.values.some(
+        (a) => rowValues.some((v) => a.wildcard ? v.startsWith(a.value) : v === a.value)
+      )
+    );
+    return negate ? !hit : hit;
+  });
+}
+function dimValue(row, dim, noteTags) {
+  if (dim === "day") return localDateString(row.timestamp);
+  if (dim === "week") {
+    const d = new Date(row.timestamp);
+    const monday = new Date(row.timestamp - (d.getDay() + 6) % 7 * DAY);
+    return `w/${monday.toISOString().slice(5, 10)}`;
+  }
+  if (dim === "session") return row.resultId;
+  const raw = factTagValue(row, dim, noteTags);
+  if (raw === void 0) return "(none)";
+  if (typeof raw === "string") return raw;
+  return raw.length ? raw.join(",") : "(none)";
+}
+function toDisplayValue(value, unit, targetUnit) {
+  if (!targetUnit || unit === targetUnit) return value;
+  return convert(value, unit, targetUnit);
+}
+function aggregate(values, agg, points, targetUnit) {
+  if (agg === "count") return points.length;
+  if (values.length === 0) return 0;
+  switch (agg) {
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "avg":
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+    case "last": {
+      const latest = [...points].sort((a, b) => b.timestamp - a.timestamp)[0];
+      return toDisplayValue(latest.value, latest.unit ?? latest.metricUnit, targetUnit);
+    }
+    case "delta":
+      return values[values.length - 1] - values[0];
+  }
+}
+function compareOp(value, op, threshold) {
+  switch (op) {
+    case ">":
+      return value > threshold;
+    case ">=":
+      return value >= threshold;
+    case "<":
+      return value < threshold;
+    case "<=":
+      return value <= threshold;
+    case "==":
+      return value === threshold;
+    case "!=":
+      return value !== threshold;
+  }
+}
+var QueryService = class {
+  store;
+  noteStore;
+  blockStore;
+  resultStore;
+  effortStore;
+  staticNoteStore;
+  staticBlockStore;
+  constructor(storesOrFactStore, noteStore, blockStore, resultStore, effortStore, staticNoteStore, staticBlockStore) {
+    if (storesOrFactStore && typeof storesOrFactStore === "object" && ("factStore" in storesOrFactStore || "noteStore" in storesOrFactStore || "blockStore" in storesOrFactStore || "resultStore" in storesOrFactStore || "effortStore" in storesOrFactStore || "staticNoteStore" in storesOrFactStore || "staticBlockStore" in storesOrFactStore)) {
+      const stores = storesOrFactStore;
+      this.store = stores.factStore ?? defaultFactStore;
+      this.noteStore = stores.noteStore ?? defaultNoteStore;
+      this.blockStore = stores.blockStore ?? defaultBlockStore;
+      this.resultStore = stores.resultStore ?? defaultResultStore;
+      this.effortStore = stores.effortStore ?? defaultEffortStore;
+      this.staticNoteStore = stores.staticNoteStore;
+      this.staticBlockStore = stores.staticBlockStore;
+    } else {
+      this.store = storesOrFactStore ?? defaultFactStore;
+      this.noteStore = noteStore ?? defaultNoteStore;
+      this.blockStore = blockStore ?? defaultBlockStore;
+      this.resultStore = resultStore ?? defaultResultStore;
+      this.effortStore = effortStore ?? defaultEffortStore;
+      this.staticNoteStore = staticNoteStore;
+      this.staticBlockStore = staticBlockStore;
+    }
+  }
+  async getFactsByTimeRange(start, end) {
+    return this.store.getFactsByTimeRange(start, end);
+  }
+  async runQuery(raw, options2 = {}) {
+    const parsed = parseQuery(raw);
+    if (isFindQuery(parsed)) {
+      return {
+        parsed: { raw, agg: "count", metric: parsed.target, filters: [], groupBy: [] },
+        series: [],
+        stages: { selected: 0, buckets: 0, aggregated: 0, groups: 0 },
+        matched: []
+      };
+    }
+    if (isRowsQuery(parsed)) {
+      return {
+        parsed: { raw, agg: "count", metric: "rows", filters: [], groupBy: [] },
+        series: [],
+        stages: { selected: 0, buckets: 0, aggregated: 0, groups: 0 },
+        matched: []
+      };
+    }
+    return this.run(parsed, options2);
+  }
+  /**
+   * Execute a rows query (rows:{…}, #949) — the session results table plane.
+   * Re-derives output statements from raw WorkoutResult logs through the
+   * ResultLogStore seam ("logs win" — facts are never read for this path).
+   */
+  async runRows(parsed, options2 = {}) {
+    const empty = { parsed, runs: [] };
+    if (parsed.error) return { ...empty, error: parsed.error };
+    const ROWS_SCOPE_KEYS = /* @__PURE__ */ new Set(["result", "block", "note"]);
+    const unsupported = parsed.filters.filter(
+      (f) => !ROWS_SCOPE_KEYS.has(f.key) || f.negate || f.values.some((v) => v.wildcard)
+    );
+    if (unsupported.length > 0) {
+      return {
+        ...empty,
+        error: `Unsupported rows filter(s): ${unsupported.map((f) => (f.negate ? "!" : "") + f.key).join(", ")}. Rows queries support exact result:, block:, note: values.`
+      };
+    }
+    const scopeValues = (key) => parsed.filters.filter((f) => f.key === key).flatMap((f) => f.values.map((v) => v.value));
+    const resultIds = scopeValues("result");
+    const blockIds = scopeValues("block");
+    const noteIds = scopeValues("note");
+    if (resultIds.length + blockIds.length + noteIds.length === 0) {
+      return { ...empty, error: "Rows query needs a scope: result:, block:, or note:." };
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const id of resultIds) {
+      const r = await this.resultStore.getResultById(id);
+      if (r) byId.set(r.id, r);
+    }
+    for (const blockContentId of blockIds) {
+      for (const r of await this.resultStore.getResultsByContentId(blockContentId)) byId.set(r.id, r);
+    }
+    for (const noteId of noteIds) {
+      for (const r of await this.resultStore.getResultsForNote(noteId)) byId.set(r.id, r);
+    }
+    let results = [...byId.values()].filter((r) => r.data?.logs?.length);
+    if (parsed.last) {
+      results = results.filter(
+        (r) => effectiveTimeWindow(r.data.endTime ?? r.createdAt ?? 0, parsed.last, void 0, options2.anchorNow)
+      );
+    }
+    results.sort((a, b) => (b.data.endTime ?? b.createdAt) - (a.data.endTime ?? a.createdAt));
+    const runs = results.map((result) => ({
+      result,
+      logs: parsed.outputType ? result.data.logs.filter((l) => l.outputType === parsed.outputType) : result.data.logs
+    })).filter((run) => run.logs.length > 0);
+    return { parsed, runs };
+  }
+  /**
+   * Execute a content-discovery query (find:note). Naive in-memory filtering
+   * per the tracer-bullet scope (#797): load all notes, then apply tag/text/
+   * time filters.
+   */
+  async runFind(parsed, options2 = {}) {
+    if (parsed.error) {
+      return { parsed, notes: [], blocks: [], stages: { selected: 0, matched: 0 } };
+    }
+    if (parsed.target === "block") {
+      return this.runFindBlock(parsed, options2);
+    }
+    if (parsed.target === "effort") {
+      return this.runFindEffort(parsed);
+    }
+    let notes = [];
+    const scope = parsed.scope || "journal";
+    if (scope === "journal" || scope === "all") {
+      notes = notes.concat(await this.noteStore.getAllNotes());
+    }
+    if (scope === "collections" || scope === "feeds" || scope === "all") {
+      let sNotes = this.staticNoteStore ? await this.staticNoteStore.getAllNotes() : [];
+      if (scope === "collections") sNotes = sNotes.filter((n) => n.sourceId?.startsWith("collection:"));
+      if (scope === "feeds") sNotes = sNotes.filter((n) => n.sourceId?.startsWith("feed:"));
+      notes = notes.concat(sNotes);
+    }
+    const selectedCount = notes.length;
+    const anchorNow = windowAnchor(notes, parsed, options2);
+    notes = applySourceFilter(notes, parsed.filters);
+    for (const filter of parsed.filters) {
+      if (filter.key === "tags" && !filter.negate) {
+        const matchingIds = /* @__PURE__ */ new Set();
+        for (const v of filter.values) {
+          const ids = await this.noteStore.getNoteIdsForTag(v.value);
+          const sIds = this.staticNoteStore ? await this.staticNoteStore.getNoteIdsForTag(v.value) : /* @__PURE__ */ new Set();
+          ids.forEach((id) => matchingIds.add(id));
+          sIds.forEach((id) => matchingIds.add(id));
+        }
+        notes = notes.filter((n) => matchingIds.has(n.id));
+      } else if (filter.key === "tags" && filter.negate) {
+        for (const v of filter.values) {
+          const ids = await this.noteStore.getNoteIdsForTag(v.value);
+          const sIds = this.staticNoteStore ? await this.staticNoteStore.getNoteIdsForTag(v.value) : /* @__PURE__ */ new Set();
+          notes = notes.filter((n) => !ids.has(n.id) && !sIds.has(n.id));
+        }
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "text" && !filter.negate) {
+        const search = filter.values.map((v) => v.value).join(" ").toLowerCase();
+        notes = notes.filter((n) => n.title.toLowerCase().includes(search));
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "type" && !filter.negate) {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        notes = notes.filter((n) => n.type && wanted.has(n.type));
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "catalog") {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        notes = notes.filter((n) => {
+          const cat = catalogOfItem(n);
+          if (!cat) return filter.negate;
+          const hit = wanted.has(cat);
+          return filter.negate ? !hit : hit;
+        });
+      }
+    }
+    if (parsed.last || options2.range) {
+      notes = notes.filter((n) => effectiveTimeWindow(n.createdAt, parsed.last, options2.range, anchorNow));
+    }
+    if (parsed.join) {
+      const joined = await this.applyMetricJoin(parsed, notes, []);
+      notes = joined.notes;
+    }
+    return { parsed, notes, blocks: [], stages: { selected: selectedCount, matched: notes.length } };
+  }
+  /**
+   * Execute a find:block query against the derived block_index store.
+   */
+  async runFindBlock(parsed, options2 = {}) {
+    let blocks = [];
+    const scope = parsed.scope || "journal";
+    if (scope === "journal" || scope === "all") {
+      blocks = blocks.concat(await this.blockStore.getAllBlocks());
+    }
+    if (scope === "collections" || scope === "feeds" || scope === "all") {
+      let sBlocks = this.staticBlockStore ? await this.staticBlockStore.getAllBlocks() : [];
+      if (scope === "collections") sBlocks = sBlocks.filter((b) => b.sourceId?.startsWith("collection:"));
+      if (scope === "feeds") sBlocks = sBlocks.filter((b) => b.sourceId?.startsWith("feed:"));
+      blocks = blocks.concat(sBlocks);
+    }
+    const selectedCount = blocks.length;
+    const anchorNow = windowAnchor(blocks, parsed, options2);
+    blocks = applySourceFilter(blocks, parsed.filters);
+    for (const filter of parsed.filters) {
+      if (filter.key === "text" && !filter.negate) {
+        const search = filter.values.map((v) => v.value).join(" ").toLowerCase();
+        blocks = blocks.filter((b) => b.rawContent.toLowerCase().includes(search));
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "type" && !filter.negate) {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        blocks = blocks.filter((b) => wanted.has(b.dataType));
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "catalog") {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        blocks = blocks.filter((b) => {
+          const cat = catalogOfItem(b);
+          if (!cat) return filter.negate;
+          const hit = wanted.has(cat);
+          return filter.negate ? !hit : hit;
+        });
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "tags" && !filter.negate) {
+        const matchingNoteIds = /* @__PURE__ */ new Set();
+        for (const v of filter.values) {
+          const ids = await this.noteStore.getNoteIdsForTag(v.value);
+          const sIds = this.staticNoteStore ? await this.staticNoteStore.getNoteIdsForTag(v.value) : /* @__PURE__ */ new Set();
+          ids.forEach((id) => matchingNoteIds.add(id));
+          sIds.forEach((id) => matchingNoteIds.add(id));
+        }
+        blocks = blocks.filter((b) => matchingNoteIds.has(b.noteId));
+      }
+    }
+    if (parsed.last || options2.range) {
+      blocks = blocks.filter((b) => effectiveTimeWindow(b.createdAt, parsed.last, options2.range, anchorNow));
+    }
+    if (parsed.join) {
+      const joined = await this.applyMetricJoin(parsed, [], blocks);
+      blocks = joined.blocks;
+    }
+    return { parsed, notes: [], blocks, stages: { selected: selectedCount, matched: blocks.length } };
+  }
+  /**
+   * Execute a find:effort query against the effort registry.
+   */
+  async runFindEffort(parsed) {
+    const all = await this.effortStore.getAllEfforts();
+    const selectedCount = all.length;
+    const matches = (effort, key, value, wildcard) => {
+      const needle = value.toLowerCase();
+      switch (key) {
+        case "effort":
+          if (wildcard) {
+            return effort.slug.includes(needle) || effort.label.toLowerCase().includes(needle) || effort.aliases.some((a) => a.toLowerCase().includes(needle));
+          }
+          return effort.slug === value || effort.label.toLowerCase() === needle || effort.aliases.some((a) => a.toLowerCase() === needle);
+        case "discipline":
+          return effort.baseAttributes.discipline === value;
+        case "intensity":
+          return effort.baseAttributes.intensityTier === value;
+        case "origin":
+          return effort.registrySource === value;
+        case "text":
+          return effort.label.toLowerCase().includes(needle) || effort.slug.includes(needle) || effort.aliases.some((a) => a.toLowerCase().includes(needle));
+        default:
+          return true;
+      }
+    };
+    let efforts = all;
+    for (const filter of parsed.filters) {
+      if (!["effort", "discipline", "intensity", "origin", "text"].includes(filter.key)) continue;
+      efforts = efforts.filter((effort) => {
+        const hit = filter.values.some((v) => matches(effort, filter.key, v.value, v.wildcard));
+        return filter.negate ? !hit : hit;
+      });
+    }
+    return { parsed, notes: [], blocks: [], efforts, stages: { selected: selectedCount, matched: efforts.length } };
+  }
+  async run(parsed, options2 = {}) {
+    const empty = {
+      parsed,
+      series: [],
+      stages: { selected: 0, buckets: 0, aggregated: 0, groups: 0 },
+      matched: []
+    };
+    if (parsed.error) return empty;
+    if (parsed.join) return this.runJoined(parsed, options2);
+    const byMetric = await this.store.getFactsByMetric(parsed.metric);
+    let candidates = byMetric;
+    if (options2.rangeStart !== void 0 || options2.rangeEnd !== void 0) {
+      const start = options2.rangeStart ?? 0;
+      const end = options2.rangeEnd ?? Number.MAX_SAFE_INTEGER;
+      const inRange = new Set((await this.store.getFactsByTimeRange(start, end)).map((row) => row.id));
+      candidates = candidates.filter((row) => inRange.has(row.id));
+    }
+    const touchesTags = parsed.filters.some((f) => f.key === "tags") || parsed.groupBy.includes("tags");
+    const noteTags = await this.loadNoteTags(candidates, touchesTags);
+    const matched = this.applyEffortScope(
+      candidates.filter((row) => matchesFilters(row, parsed.filters, noteTags)),
+      parsed
+    );
+    return this.buildResult(matched, parsed, options2, noteTags);
+  }
+  /**
+   * Stages 2–4 — BUCKET → GROUP → AGGREGATE over an already-selected +
+   * filtered `matched` set.
+   */
+  buildResult(matched, parsed, options2, noteTags) {
+    const timeDim = parsed.groupBy.find((d) => d === "day" || d === "week");
+    const tagDims = parsed.groupBy.filter((d) => d !== "day" && d !== "week");
+    const bucketMs = timeDim ? (timeDim === "week" ? 7 : 1) * DAY : parsed.rollup ? parsed.rollup.size * (parsed.rollup.unit === "w" ? 7 : 1) * DAY : null;
+    const bucketKey = (ts) => bucketMs ? Math.floor(ts / bucketMs) : 0;
+    const bucketCount = bucketMs ? new Set(matched.map((p) => bucketKey(p.timestamp))).size : matched.length ? 1 : 0;
+    const { unit: targetUnit, convert: shouldConvert } = resolveDisplayUnit(matched, {
+      directive: parsed.displayUnit,
+      preferred: options2.preferredUnit
+    });
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of matched) {
+      const key = tagDims.length ? tagDims.map((d) => dimValue(row, d, noteTags)).join(" \xB7 ") : parsed.metric;
+      const bucket = groups.get(key);
+      if (bucket) bucket.push(row);
+      else groups.set(key, [row]);
+    }
+    const series = [...groups.entries()].map(([key, rows]) => {
+      const byBucket = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const b = bucketKey(row.timestamp);
+        const members = byBucket.get(b);
+        if (members) members.push(row);
+        else byBucket.set(b, [row]);
+      }
+      const points = [...byBucket.entries()].sort(([a], [b]) => a - b).map(([b, members]) => {
+        const values = members.map(
+          (m) => toDisplayValue(m.value, m.unit ?? m.metricUnit, shouldConvert ? targetUnit : void 0)
+        );
+        return {
+          ts: bucketMs ? b * bucketMs + bucketMs / 2 : Math.min(...members.map((m) => m.timestamp)),
+          value: Math.round(aggregate(values, parsed.agg, members, shouldConvert ? targetUnit : void 0) * 100) / 100
+        };
+      });
+      const seriesUnit = shouldConvert ? targetUnit : rows[0]?.unit ?? rows[0]?.metricUnit;
+      return { key, label: key, points, unit: seriesUnit };
+    });
+    const aggregated = series.reduce((n, s) => n + s.points.length, 0);
+    const scalar = series.length === 1 && series[0].points.length === 1 ? series[0].points[0].value : void 0;
+    const resultUnit = series.length > 0 ? series[0].unit : void 0;
+    return {
+      parsed,
+      series,
+      stages: { selected: matched.length, buckets: bucketCount, aggregated, groups: series.length },
+      matched,
+      scalar,
+      unit: resultUnit
+    };
+  }
+  /** Direction 2 — re-derive the metric from raw logs, restricted to the
+   *  blockContentIds owned by the find predicate's content matches. */
+  async runJoined(parsed, options2) {
+    const empty = {
+      parsed,
+      series: [],
+      stages: { selected: 0, buckets: 0, aggregated: 0, groups: 0 },
+      matched: []
+    };
+    const join = parsed.join;
+    const findResult = await this.runFind({
+      raw: "",
+      target: join.target,
+      filters: join.filters,
+      scope: join.scope,
+      last: join.last
+    });
+    const contentIds = await this.contentIdsFromFindResult(findResult);
+    if (contentIds.size === 0) return empty;
+    let facts = await this.deriveMetricFacts(contentIds, parsed.metric);
+    if (facts.length === 0) return empty;
+    if (options2.rangeStart !== void 0 || options2.rangeEnd !== void 0) {
+      const start = options2.rangeStart ?? 0;
+      const end = options2.rangeEnd ?? Number.MAX_SAFE_INTEGER;
+      facts = facts.filter((f) => f.timestamp >= start && f.timestamp <= end);
+    }
+    const touchesTags = parsed.filters.some((f) => f.key === "tags") || parsed.groupBy.includes("tags");
+    const noteTags = await this.loadNoteTags(facts, touchesTags);
+    const matched = this.applyEffortScope(
+      facts.filter((f) => matchesFilters(f, parsed.filters, noteTags)),
+      parsed
+    );
+    return this.buildResult(matched, parsed, options2, noteTags);
+  }
+  /** Direction 1 — keep only content owning a wod block whose raw-log metric
+   *  aggregate satisfies the predicate. `notes` for find:note, `blocks` for
+   *  find:block. */
+  async applyMetricJoin(parsed, notes, blocks) {
+    const join = parsed.join;
+    const noteToContent = await this.noteContentMap(new Set(notes.map((n) => n.id)));
+    const candidateIds = /* @__PURE__ */ new Set();
+    for (const set of noteToContent.values()) for (const id of set) candidateIds.add(id);
+    for (const b of blocks) if (b.dataType === "wod" && b.blockContentId) candidateIds.add(b.blockContentId);
+    const passing = await this.contentIdsSatisfying(candidateIds, join);
+    blocks = blocks.filter((b) => b.dataType === "wod" && !!b.blockContentId && passing.has(b.blockContentId));
+    notes = notes.filter((n) => {
+      const cids = noteToContent.get(n.id);
+      return !!cids && [...cids].some((id) => passing.has(id));
+    });
+    return { notes, blocks };
+  }
+  /** Re-derive the metric from raw logs for each content id, aggregate per id,
+   *  and return the ids whose aggregate satisfies the join predicate. */
+  async contentIdsSatisfying(contentIds, join) {
+    const facts = await this.deriveMetricFacts(contentIds, join.metric);
+    const noteTags = await this.loadNoteTags(facts, join.filters.some((f) => f.key === "tags"));
+    const filtered = this.applyEffortScope(
+      facts.filter((f) => matchesFilters(f, join.filters, noteTags)),
+      { filters: join.filters, groupBy: [] }
+    );
+    const byContent = /* @__PURE__ */ new Map();
+    for (const f of filtered) {
+      const cid = f.blockContentId ?? "";
+      const arr = byContent.get(cid);
+      if (arr) arr.push(f);
+      else byContent.set(cid, [f]);
+    }
+    const passing = /* @__PURE__ */ new Set();
+    for (const [cid, rows] of byContent) {
+      const values = rows.map((r) => r.value);
+      if (compareOp(aggregate(values, join.agg, rows, void 0), join.operator, join.threshold)) passing.add(cid);
+    }
+    return passing;
+  }
+  /** Filter per-effort vs un-attributed overall summary rows to avoid
+   *  double-counting. */
+  applyEffortScope(matched, scope) {
+    if (scope.groupBy.includes("effort") || scope.filters.some((f) => f.key === "effort")) {
+      return matched.some((r) => r.effortSlug !== void 0) ? matched.filter((r) => r.effortSlug !== void 0) : matched;
+    }
+    return matched.some((r) => r.effortSlug === void 0) ? matched.filter((r) => r.effortSlug === void 0) : matched;
+  }
+  /** Re-derive summary facts for one Canonical Metric Key from RAW WorkoutResult
+   *  logs across the given content ids — the cross-store join source. One fact
+   *  row per result (normalizeSummaryFacts dedupes within a result). */
+  async deriveMetricFacts(contentIds, metricKey) {
+    const out = [];
+    const ids = [...new Set(contentIds)];
+    await Promise.all(ids.map(async (blockContentId) => {
+      const results = await this.resultStore.getResultsByContentId(blockContentId);
+      for (const result of results) {
+        const facts = normalizeSummaryFacts(result.data.logs ?? [], {
+          noteId: result.noteId,
+          resultId: result.id,
+          segmentId: result.segmentId,
+          segmentVersion: result.segmentVersion,
+          blockContentId,
+          origin: result.origin,
+          pageId: result.pageId,
+          workoutTimestamp: result.createdAt
+        });
+        for (const f of facts) if (f.metricKey === metricKey) out.push(f);
+      }
+    }));
+    return out;
+  }
+  /** All content blocks across the journal + static corpus. */
+  async allContentBlocks() {
+    const blocks = await this.blockStore.getAllBlocks();
+    const staticBlocks = this.staticBlockStore ? await this.staticBlockStore.getAllBlocks() : [];
+    return blocks.concat(staticBlocks);
+  }
+  /** Map each note id to the wod blockContentIds it owns. */
+  async noteContentMap(noteIds) {
+    const map = /* @__PURE__ */ new Map();
+    if (!noteIds.size) return map;
+    const allBlocks = await this.allContentBlocks();
+    for (const b of allBlocks) {
+      if (b.dataType !== "wod" || !b.blockContentId || !noteIds.has(b.noteId)) continue;
+      let set = map.get(b.noteId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        map.set(b.noteId, set);
+      }
+      set.add(b.blockContentId);
+    }
+    return map;
+  }
+  /** Collect wod blockContentIds owned by a find query's content matches. */
+  async contentIdsFromFindResult(findResult) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const b of findResult.blocks) if (b.dataType === "wod" && b.blockContentId) ids.add(b.blockContentId);
+    if (findResult.notes.length) {
+      const noteIds = new Set(findResult.notes.map((n) => n.id));
+      const noteMap = await this.noteContentMap(noteIds);
+      for (const set of noteMap.values()) for (const id of set) ids.add(id);
+    }
+    return ids;
+  }
+  /** Load note tag labels only when the query touches 'tags'. */
+  async loadNoteTags(rows, touchesTags) {
+    const noteTags = /* @__PURE__ */ new Map();
+    if (!touchesTags) return noteTags;
+    const noteIds = [...new Set(rows.map((r) => r.noteId))];
+    await Promise.all(noteIds.map(async (id) => noteTags.set(id, await this.store.getNoteTagLabels(id))));
+    return noteTags;
+  }
+};
+
+// src/dashboard/model.ts
+var DASHBOARD_WIDGET_TYPES = [
+  "table",
+  "value",
+  "timeseries",
+  "bar",
+  "toplist",
+  "stacked-bar",
+  "goal-rings",
+  "zone-distribution"
+];
+function isDashboardWidgetType(type) {
+  return DASHBOARD_WIDGET_TYPES.includes(type);
+}
+function resolveWidgetType(type) {
+  return type == null || type === "" ? "table" : type;
+}
+function unknownWidgetTypeMessage(type) {
+  return `unknown widget type "${type}"`;
+}
+function unknownTokensMessage(missing) {
+  return `unknown token${missing.length > 1 ? "s" : ""}: ${missing.map((m) => `$${m}`).join(", ")}`;
+}
+var PLANNED_WIDGET_TYPES = [];
+var KNOWN_CALC_METRICS = new Set(WQL_CALC_TARGETS);
+function isProposedMetric(metricKey) {
+  if (!metricKey) return false;
+  if (!metricKey.startsWith("calc.")) return false;
+  return !KNOWN_CALC_METRICS.has(metricKey);
+}
+var DASHBOARD_GRID_MAX_COLS = 4;
+function parseQueryWidgetSuffix(suffix) {
+  if (suffix === "") return { type: "", error: 'missing widget type after "query:"' };
+  let rest = suffix.toLowerCase();
+  let spanCols;
+  let spanFull;
+  if (rest.endsWith("-full")) {
+    spanFull = true;
+    rest = rest.slice(0, -"-full".length);
+  } else {
+    const spanMatch = rest.match(/-(\d+)$/);
+    if (spanMatch) {
+      spanCols = Number(spanMatch[1]);
+      rest = rest.slice(0, -spanMatch[0].length);
+    }
+  }
+  if (rest === "" || !/^[a-z][a-z0-9-]*$/.test(rest)) {
+    return { type: rest, spanCols, spanFull, error: `malformed widget type "${suffix}"` };
+  }
+  if (/-(\d+|full)$/.test(rest)) {
+    return { type: rest, spanCols, spanFull, error: `malformed widget suffix "${suffix}"` };
+  }
+  if (spanCols != null && (spanCols < 1 || spanCols > DASHBOARD_GRID_MAX_COLS)) {
+    return { type: rest, spanCols, spanFull, error: `span ${spanCols} outside 1..${DASHBOARD_GRID_MAX_COLS}` };
+  }
+  return { type: rest, spanCols, spanFull };
+}
+var TOKEN_PREFIX = "dashboard.";
+function isDashboardMeta(meta) {
+  return meta["dashboard"] === "true" || meta["dashboard"] === true;
+}
+function extractDashboardTokens(meta) {
+  const tokens = [];
+  for (const [key, value] of Object.entries(meta)) {
+    if (!key.startsWith(TOKEN_PREFIX) || key === TOKEN_PREFIX) continue;
+    const name = key.slice(TOKEN_PREFIX.length);
+    if (name === "") continue;
+    if (Array.isArray(value)) {
+      if (value.length > 0) tokens.push({ name, values: value.map(String), isList: true });
+    } else {
+      tokens.push({ name, values: [String(value)], isList: false });
+    }
+  }
+  return tokens;
+}
+function defaultTokenValues(tokens) {
+  const values = {};
+  for (const token of tokens) values[token.name] = token.values[0];
+  return values;
+}
+function setDashboardTokenValue(meta, name, value) {
+  const key = `${TOKEN_PREFIX}${name}`;
+  const current = meta[key];
+  const next = { ...meta };
+  if (Array.isArray(current)) {
+    if (!current.includes(value)) return meta;
+    next[key] = [value, ...current.filter((v) => v !== value)];
+  } else if (current != null) {
+    next[key] = typeof current === "number" && !isNaN(Number(value)) ? Number(value) : value;
+  } else {
+    next[key] = value;
+  }
+  return next;
+}
+var TOKEN_REF_RE = /\$([A-Za-z][\w-]*)/g;
+function substituteTokens(query, values) {
+  const missing = /* @__PURE__ */ new Set();
+  const substituted = query.replace(TOKEN_REF_RE, (raw, name) => {
+    const value = values[name];
+    if (value == null) {
+      missing.add(name);
+      return raw;
+    }
+    return value;
+  });
+  return { query: substituted, missing: [...missing] };
+}
+function referencedTokens(query) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(TOKEN_REF_RE)) names.add(match[1]);
+  return [...names];
+}
+function splitWidgetBody(body) {
+  const trimmed = body.trim();
+  const sep = trimmed.indexOf(" / ");
+  if (sep === -1) return { query: trimmed, params: [] };
+  const query = trimmed.slice(0, sep).trim();
+  const params = trimmed.slice(sep + 3).split(/\s+/).map((p) => p.trim()).filter((p) => p.length > 0);
+  return { query, params };
+}
+function headingText(content) {
+  const line = content.split("\n", 1)[0].replace(/^#{1,6}\s*/, "").trim();
+  return line === "" ? void 0 : line;
+}
+function paragraphText(content) {
+  const text = content.replace(/\s*\n\s*/g, " ").trim();
+  return text === "" ? void 0 : text;
+}
+function buildDashboardDocument(sections, meta) {
+  const widgets = [];
+  sections.forEach((section, i) => {
+    if (section.type !== "query") return;
+    const bodyLine = section.content.split("\n").map((l) => l.trim()).find((l) => l !== "" && !l.startsWith("#")) ?? "";
+    const { query, params } = splitWidgetBody(bodyLine);
+    let title;
+    let question;
+    const above = sections[i - 1];
+    if (above?.type === "markdown" && above.subtype === "paragraph") {
+      question = paragraphText(above.content);
+      const heading = sections[i - 2];
+      if (heading?.type === "markdown" && heading.subtype === "heading") {
+        title = headingText(heading.content);
+      }
+    } else if (above?.type === "markdown" && above.subtype === "heading") {
+      title = headingText(above.content);
+    }
+    widgets.push({
+      key: `w${widgets.length}`,
+      type: section.widgetType ?? "",
+      spanCols: section.spanCols,
+      spanFull: section.spanFull,
+      widgetError: section.widgetError,
+      body: bodyLine,
+      query,
+      params,
+      title,
+      question
+    });
+  });
+  const titleMeta = meta["title"];
+  return {
+    isDashboard: isDashboardMeta(meta),
+    title: typeof titleMeta === "string" && titleMeta !== "" ? titleMeta : void 0,
+    tokens: extractDashboardTokens(meta),
+    widgets
+  };
+}
+
+// src/dashboard/parser.ts
+function parseDashboardNote(rawContent) {
+  const { meta } = parseFrontmatter(rawContent);
+  const lines = rawContent.split(/\r?\n/);
+  const sections = [];
+  let i = 0;
+  if (lines.length > 0 && lines[0].trim() === "---") {
+    i = 1;
+    while (i < lines.length && lines[i].trim() !== "---") {
+      i++;
+    }
+    i++;
+  }
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^```query/.test(trimmed)) {
+      const tag = trimmed.slice(3).split(/[\s\t]/)[0].toLowerCase();
+      let widgetType;
+      let spanCols;
+      let spanFull;
+      let widgetError;
+      if (tag.startsWith("query:")) {
+        const spec = parseQueryWidgetSuffix(tag.slice("query:".length));
+        widgetType = spec.type || void 0;
+        spanCols = spec.spanCols;
+        spanFull = spec.spanFull;
+        widgetError = spec.error;
+      }
+      const startLine = i;
+      i++;
+      const bodyLines = [];
+      while (i < lines.length && !/^```[\w\d_:-]*$/.test(lines[i].trim())) {
+        bodyLines.push(lines[i]);
+        i++;
+      }
+      const endLine = i;
+      sections.push({
+        type: "query",
+        content: bodyLines.join("\n"),
+        widgetType,
+        spanCols,
+        spanFull,
+        widgetError,
+        startLine,
+        endLine
+      });
+      i++;
+      continue;
+    }
+    if (/^```[\w\d_:-]*$/.test(trimmed)) {
+      const startLine = i;
+      const fenceLines = [lines[i]];
+      i++;
+      while (i < lines.length && !/^```[\w\d_:-]*$/.test(lines[i].trim())) {
+        fenceLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) {
+        fenceLines.push(lines[i]);
+        i++;
+      }
+      sections.push({
+        type: "markdown",
+        subtype: "paragraph",
+        content: fenceLines.join("\n"),
+        startLine,
+        endLine: i - 1
+      });
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      sections.push({
+        type: "markdown",
+        subtype: "heading",
+        content: trimmed,
+        startLine: i,
+        endLine: i
+      });
+      i++;
+      continue;
+    }
+    if (trimmed !== "") {
+      const startLine = i;
+      const paraLines = [];
+      while (i < lines.length && lines[i].trim() !== "" && !lines[i].trim().startsWith("#") && !/^```[\w\d_:-]*$/.test(lines[i].trim())) {
+        paraLines.push(lines[i]);
+        i++;
+      }
+      sections.push({
+        type: "markdown",
+        subtype: "paragraph",
+        content: paraLines.join("\n"),
+        startLine,
+        endLine: i - 1
+      });
+      continue;
+    }
+    i++;
+  }
+  return { meta, sections };
+}
+
+// src/dashboard/scaffold.ts
+var DEFAULT_DASHBOARD_TITLE = "New Dashboard";
+function dashboardSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "dashboard";
+}
+function buildDashboardScaffold(title = DEFAULT_DASHBOARD_TITLE) {
+  return `---
+dashboard: true
+dashboard.active: true
+title: ${title}
+slug: ${dashboardSlug(title)}
+dashboard.metric: [totalVolume, totalReps]
+---
+
+## Weekly Trend
+How does $metric trend week over week?
+
+\`\`\`query:timeseries
+sum:$metric{} rollup:1w
+\`\`\`
+`;
+}
+
+exports.DASHBOARD_GRID_MAX_COLS = DASHBOARD_GRID_MAX_COLS;
+exports.DASHBOARD_WIDGET_TYPES = DASHBOARD_WIDGET_TYPES;
+exports.DEFAULT_DASHBOARD_TITLE = DEFAULT_DASHBOARD_TITLE;
+exports.DISCIPLINE_FACTORS = DISCIPLINE_FACTORS;
+exports.EFFORT_DISCIPLINES = EFFORT_DISCIPLINES;
+exports.KG_PER_LB = KG_PER_LB;
+exports.PLANNED_WIDGET_TYPES = PLANNED_WIDGET_TYPES;
+exports.QueryService = QueryService;
+exports.UNIT_FAMILIES = UNIT_FAMILIES;
+exports.WQL_AGGREGATORS = WQL_AGGREGATORS;
+exports.WQL_CALC_TARGETS = WQL_CALC_TARGETS;
+exports.WQL_COMPARISON_OPS = WQL_COMPARISON_OPS;
+exports.WQL_CONTENT_FILTER_KEYS = WQL_CONTENT_FILTER_KEYS;
+exports.WQL_DISPLAY_UNITS = WQL_DISPLAY_UNITS;
+exports.WQL_FIND_TARGETS = WQL_FIND_TARGETS;
+exports.WQL_GRAINS = WQL_GRAINS;
+exports.WQL_INTENSITY_TIERS = WQL_INTENSITY_TIERS;
+exports.WQL_KEYWORDS = WQL_KEYWORDS;
+exports.WQL_METRIC_AGGREGATES = WQL_METRIC_AGGREGATES;
+exports.WQL_METRIC_FAMILIES = WQL_METRIC_FAMILIES;
+exports.WQL_ROLLUP_PERIODS = WQL_ROLLUP_PERIODS;
+exports.WQL_SCOPES = WQL_SCOPES;
+exports.WQL_SOURCES = WQL_SOURCES;
+exports.WQL_TAG_KEYS = WQL_TAG_KEYS;
+exports.WQL_VIRTUAL_DIMS = WQL_VIRTUAL_DIMS;
+exports.buildDashboardDocument = buildDashboardDocument;
+exports.buildDashboardScaffold = buildDashboardScaffold;
+exports.convert = convert;
+exports.dashboardSlug = dashboardSlug;
+exports.defaultTokenValues = defaultTokenValues;
+exports.disciplineFactorFor = disciplineFactorFor;
+exports.extractDashboardTokens = extractDashboardTokens;
+exports.extractFrontmatterTags = extractFrontmatterTags;
+exports.getList = getList;
+exports.getScalar = getScalar;
+exports.getUnitFamily = getUnitFamily;
+exports.isDashboardMeta = isDashboardMeta;
+exports.isDashboardWidgetType = isDashboardWidgetType;
+exports.isEffortDiscipline = isEffortDiscipline;
+exports.isFindQuery = isFindQuery;
+exports.isProposedMetric = isProposedMetric;
+exports.isRowsQuery = isRowsQuery;
+exports.normalizeSummaryFacts = normalizeSummaryFacts;
+exports.parseDashboardNote = parseDashboardNote;
+exports.parseFlatProperties = parseFlatProperties;
+exports.parseFrontmatter = parseFrontmatter;
+exports.parseFrontmatterBody = parseFrontmatterBody;
+exports.parseFrontmatterCategories = parseFrontmatterCategories;
+exports.parseFrontmatterProps = parseFrontmatterProps;
+exports.parseQuery = parseQuery;
+exports.parseQueryWidgetSuffix = parseQueryWidgetSuffix;
+exports.parseWqlSuffixes = parseWqlSuffixes;
+exports.referencedTokens = referencedTokens;
+exports.resolveCanonicalMetricKey = resolveCanonicalMetricKey;
+exports.resolveDisplayUnit = resolveDisplayUnit;
+exports.resolveWidgetType = resolveWidgetType;
+exports.serializeFrontmatter = serializeFrontmatter;
+exports.setDashboardTokenValue = setDashboardTokenValue;
+exports.splitAtWhere = splitAtWhere;
+exports.splitWidgetBody = splitWidgetBody;
+exports.staticNotesFromBlocks = staticNotesFromBlocks;
+exports.staticTagIndexFromBlocks = staticTagIndexFromBlocks;
+exports.stripFrontmatter = stripFrontmatter;
+exports.substituteTokens = substituteTokens;
+exports.unknownTokensMessage = unknownTokensMessage;
+exports.unknownWidgetTypeMessage = unknownWidgetTypeMessage;
+exports.wql = wql;
+exports.wqlCompletion = wqlCompletion;
+exports.wqlCompletionSource = wqlCompletionSource;
+exports.wqlHighlightStyle = wqlHighlightStyle;
+exports.wqlLanguage = wqlLanguage;
+exports.wqlParser = parser;
+exports.wqlTerms = wql_parser_terms_exports;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map