@holistics/cli-core 2.3.30 → 2.3.31

package/dist/commands.js

@@ -27799,7 +27799,7 @@ var require_dist3 = __commonJS((exports2) => {
   exports2.default = deferred;
 });
 // package.json
-var version = "2.3.30";
+var version = "2.3.31";
 
 // ../../node_modules/.pnpm/@commander-js+extra-typings@13.1.0_commander@13.1.0/node_modules/@commander-js/extra-typings/esm.mjs
 var import__ = __toESM(require_extra_typings(), 1);
@@ -147904,6 +147904,840 @@ function _transform(e16, t) {
   }
 }
 var transform = Rr3.wrapFuncWithinActiveSpan(_transform);
+var DEFAULT_WIDTH = 80;
+var NIL = { t: "nil" };
+var text = (e16) => ({
+  t: "text",
+  s: e16
+});
+var line = {
+  t: "line",
+  flat: " "
+};
+var softline = {
+  t: "line",
+  flat: ""
+};
+var hardline = { t: "hard" };
+var nest = (e16, t) => ({
+  t: "nest",
+  n: e16,
+  d: t
+});
+var group = (e16) => ({
+  t: "group",
+  d: e16
+});
+function cat(...e16) {
+  return e16.reduce((e17, t) => ({
+    t: "cat",
+    a: e17,
+    b: t
+  }), NIL);
+}
+function join(e16, t) {
+  return t.length === 0 ? NIL : t.reduce((t3, n, r3) => r3 === 0 ? n : cat(t3, e16, n));
+}
+function fits(e16, t) {
+  let n = e16, r3 = t.slice();
+  for (;n >= 0; ) {
+    let e17 = r3.pop();
+    if (!e17)
+      return true;
+    let [t3, i, a] = e17;
+    switch (a.t) {
+      case "nil":
+        break;
+      case "text":
+        n -= a.s.length;
+        break;
+      case "cat":
+        r3.push([
+          t3,
+          i,
+          a.b
+        ], [
+          t3,
+          i,
+          a.a
+        ]);
+        break;
+      case "nest":
+        r3.push([
+          t3 + a.n,
+          i,
+          a.d
+        ]);
+        break;
+      case "group":
+        r3.push([
+          t3,
+          "flat",
+          a.d
+        ]);
+        break;
+      case "hard":
+        return false;
+      case "line":
+        if (i === "flat") {
+          n -= a.flat.length;
+          break;
+        }
+        return true;
+      default:
+        break;
+    }
+  }
+  return false;
+}
+function render(e16, t) {
+  let n = "", r3 = 0, i = [[
+    0,
+    "break",
+    t
+  ]];
+  for (;i.length; ) {
+    let [t3, a, s3] = i.pop();
+    switch (s3.t) {
+      case "nil":
+        break;
+      case "text":
+        n += s3.s, r3 += s3.s.length;
+        break;
+      case "cat":
+        i.push([
+          t3,
+          a,
+          s3.b
+        ], [
+          t3,
+          a,
+          s3.a
+        ]);
+        break;
+      case "nest":
+        i.push([
+          t3 + s3.n,
+          a,
+          s3.d
+        ]);
+        break;
+      case "hard":
+        n += `
+${" ".repeat(t3)}`, r3 = t3;
+        break;
+      case "line":
+        a === "flat" ? (n += s3.flat, r3 += s3.flat.length) : (n += `
+${" ".repeat(t3)}`, r3 = t3);
+        break;
+      case "group": {
+        let n3 = [
+          t3,
+          "flat",
+          s3.d
+        ];
+        i.push(fits(e16 - r3, [n3]) ? n3 : [
+          t3,
+          "break",
+          s3.d
+        ]);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return n;
+}
+var INFIX_PREC = {
+  [Kind.OR_KEYWORD]: 3,
+  [Kind.AND_KEYWORD]: 4,
+  [Kind.EQUAL_EQUAL]: 5,
+  [Kind.EXCLAMATION_EQUAL]: 5,
+  [Kind.IS_KEYWORD]: 5,
+  [Kind.IN_KEYWORD]: 5,
+  [Kind.MATCH_KEYWORD]: 5,
+  [Kind.MATCHES_KEYWORD]: 5,
+  [Kind.LIKE_KEYWORD]: 5,
+  [Kind.ILIKE_KEYWORD]: 5,
+  [Kind.LESS_THAN]: 7,
+  [Kind.LESS_THAN_EQUAL]: 7,
+  [Kind.GREATER_THAN]: 7,
+  [Kind.GREATER_THAN_EQUAL]: 7,
+  [Kind.BAR]: 9,
+  [Kind.PLUS]: 10,
+  [Kind.MINUS]: 10,
+  [Kind.STAR]: 12,
+  [Kind.SLASH]: 12
+};
+var PREFIX_PREC = 14;
+function precOf(e16) {
+  switch (e16.kind) {
+    case Kind.INFIX_EXPRESSION:
+      return INFIX_PREC[e16.operator.kind] ?? 0;
+    case Kind.PIPE_EXPRESSION:
+      return INFIX_PREC[Kind.BAR];
+    case Kind.PREFIX_EXPRESSION:
+      return PREFIX_PREC;
+    default:
+      return Infinity;
+  }
+}
+function opNot(e16) {
+  return e16.not === true;
+}
+function infixOpText(e16) {
+  let t = opNot(e16);
+  switch (e16.kind) {
+    case Kind.PLUS:
+      return "+";
+    case Kind.MINUS:
+      return "-";
+    case Kind.STAR:
+      return "*";
+    case Kind.SLASH:
+      return "/";
+    case Kind.EQUAL_EQUAL:
+      return "==";
+    case Kind.EXCLAMATION_EQUAL:
+      return "!=";
+    case Kind.GREATER_THAN:
+      return ">";
+    case Kind.GREATER_THAN_EQUAL:
+      return ">=";
+    case Kind.LESS_THAN:
+      return "<";
+    case Kind.LESS_THAN_EQUAL:
+      return "<=";
+    case Kind.AND_KEYWORD:
+      return "and";
+    case Kind.OR_KEYWORD:
+      return "or";
+    case Kind.IS_KEYWORD:
+      return t ? "is not" : "is";
+    case Kind.IN_KEYWORD:
+      return t ? "not in" : "in";
+    case Kind.LIKE_KEYWORD:
+      return t ? "not like" : "like";
+    case Kind.ILIKE_KEYWORD:
+      return t ? "not ilike" : "ilike";
+    case Kind.MATCH_KEYWORD:
+      return "match";
+    case Kind.MATCHES_KEYWORD:
+      return "matches";
+    case Kind.BAR:
+      return "|";
+    default:
+      return String(e16.kind);
+  }
+}
+var parens = (e16) => group(cat(text("("), nest(2, cat(softline, e16)), softline, text(")")));
+function operandDoc(e16, t, n) {
+  let r3 = precOf(e16), i = n ? r3 <= t : r3 < t, a = docOf(e16);
+  return i ? parens(a) : a;
+}
+function flattenLogical(e16, t) {
+  if (e16.kind === Kind.INFIX_EXPRESSION) {
+    let n = e16;
+    if (n.operator.kind === t && !opNot(n.operator))
+      return [...flattenLogical(n.left, t), n.right];
+  }
+  return [e16];
+}
+function infixDoc(e16) {
+  let t = e16.operator.kind, n = INFIX_PREC[t] ?? 0;
+  if ((t === Kind.AND_KEYWORD || t === Kind.OR_KEYWORD) && !opNot(e16.operator)) {
+    let r4 = infixOpText(e16.operator), i3 = flattenLogical(e16, t), a = operandDoc(i3[0], n, false);
+    for (let e17 = 1;e17 < i3.length; e17++)
+      a = cat(a, line, text(`${r4} `), operandDoc(i3[e17], n, true));
+    return group(a);
+  }
+  let r3 = operandDoc(e16.left, n, false), i = operandDoc(e16.right, n, true);
+  return group(cat(r3, text(` ${infixOpText(e16.operator)}`), nest(2, cat(line, i))));
+}
+function prefixDoc(e16) {
+  let t = precOf(e16.right) < PREFIX_PREC || e16.right.kind === Kind.PREFIX_EXPRESSION ? parens(docOf(e16.right)) : docOf(e16.right);
+  return e16.operator.kind === Kind.NOT_KEYWORD ? cat(text("not "), t) : cat(text(e16.operator.kind === Kind.MINUS ? "-" : "!"), t);
+}
+function collectPipe(e16) {
+  if (e16.kind === Kind.PIPE_EXPRESSION) {
+    let t = e16, n = collectPipe(t.left);
+    return {
+      head: n.head,
+      stages: [...n.stages, t.right]
+    };
+  }
+  return {
+    head: e16,
+    stages: []
+  };
+}
+function pipeDoc(e16) {
+  let { head: t, stages: n } = collectPipe(e16), r3 = INFIX_PREC[Kind.BAR], i = precOf(t) < r3 ? parens(docOf(t)) : docOf(t);
+  for (let e17 of n)
+    i = cat(i, text(" |"), line, docOf(e17));
+  return group(i);
+}
+function identDoc(e16) {
+  return text((e16.fromGlobal ? "::" : "") + e16.value);
+}
+function callDoc(e16, t) {
+  return t.length === 0 ? text(`${e16}()`) : group(cat(text(`${e16}(`), nest(2, cat(softline, join(cat(text(","), line), t))), softline, text(")")));
+}
+function listDoc(e16, t, n) {
+  return n.length === 0 ? text(e16 + t) : group(cat(text(e16), nest(2, cat(softline, join(cat(text(","), line), n))), softline, text(t)));
+}
+function sectionBlock(e16, t) {
+  return t.length === 0 ? text(`${e16} {}`) : group(cat(text(`${e16} {`), nest(2, cat(line, join(cat(text(","), line), t))), line, text("}")));
+}
+function nestedBlock(e16, t) {
+  return group(cat(text(`${e16} {`), nest(2, cat(line, join(line, t))), line, text("}")));
+}
+function exploreDoc(e16) {
+  let t = [], n = e16.dimensions;
+  if (Array.isArray(n))
+    n.length && t.push(sectionBlock("dimensions", n.map(docOf)));
+  else {
+    let e17 = n;
+    t.push(nestedBlock("dimensions", [sectionBlock("rows", e17.rows.map(docOf)), sectionBlock("columns", e17.columns.map(docOf))]));
+  }
+  return e16.measures.length && t.push(sectionBlock("measures", e16.measures.map(docOf))), e16.filters.length && t.push(sectionBlock("filters", e16.filters.map(docOf))), e16.having.length && t.push(sectionBlock("having", e16.having.map(docOf))), e16.relationships.length && t.push(sectionBlock("relationships", e16.relationships.map(docOf))), e16.options.length && t.push(sectionBlock("options", e16.options.map(docOf))), e16.params.length && t.push(sectionBlock("params", e16.params.map(docOf))), e16.sorts.length && t.push(sectionBlock("sorts", e16.sorts.map(sortDoc))), t.length === 0 && t.push(text("dimensions {}")), group(cat(text("explore {"), nest(2, cat(line, join(line, t))), line, text("}")));
+}
+function sortDoc([e16, t]) {
+  return text(`${e16.value} ${t.toLowerCase()}`);
+}
+function paramInputDoc(e16) {
+  let t = [docOf(e16.field), text(e16.operator.value)];
+  return e16.values && t.push(docOf(e16.values)), e16.modifier && t.push(docOf(e16.modifier)), group(join(line, t));
+}
+function quote(e16) {
+  return `'${e16.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f").replace(/[\b]/g, "\\b")}'`;
+}
+var BARE_WORD = /^[a-zA-Z]+$/;
+var BARE_DATETIME = /^\d{4}(-\d{2}){0,2}( \d{2}:\d{2}(:\d{2})?)?( - \d{4}(-\d{2}){0,2}( \d{2}:\d{2}(:\d{2})?)?)?$/;
+function datetimeText(e16) {
+  return BARE_WORD.test(e16) || BARE_DATETIME.test(e16) ? `@${e16}` : `@(${e16})`;
+}
+function deriveBlockDoc(e16) {
+  let t = e16.exprs.map(docOf);
+  return group(cat(text("derive {"), nest(2, cat(line, join(cat(text(";"), line), t))), line, text("}")));
+}
+function docOf(e16) {
+  switch (e16.kind) {
+    case Kind.PROGRAM:
+      return deriveBlockDoc(e16);
+    case Kind.IDENTIFIER:
+      return identDoc(e16);
+    case Kind.DOT_EXPRESSION: {
+      let t = e16;
+      return cat(docOf(t.left), text("."), identDoc(t.right));
+    }
+    case Kind.FUNCTION_CALL: {
+      let t = e16;
+      return callDoc(t.name.value, t.args.map(docOf));
+    }
+    case Kind.PIPE_EXPRESSION:
+      return pipeDoc(e16);
+    case Kind.NAMED_EXPRESSION: {
+      let t = e16;
+      return cat(text(`${t.name.value}: `), docOf(t.expr));
+    }
+    case Kind.INFIX_EXPRESSION:
+      return infixDoc(e16);
+    case Kind.PREFIX_EXPRESSION:
+      return prefixDoc(e16);
+    case Kind.BIZ_CAL: {
+      let t = e16;
+      return cat(text(`[${t.name.value}]: `), docOf(t.expr));
+    }
+    case Kind.BIZ_CAL_REF:
+      return text(`[${e16.value}]`);
+    case Kind.GROUPING_SET:
+      return listDoc("(", ")", e16.groupingSet.map(docOf));
+    case Kind.ROW:
+      return listDoc("{", "}", e16.columns.map(docOf));
+    case Kind.FIELD_DECLARATION: {
+      let t = e16;
+      return group(cat(text(`${t.type} `), docOf(t.name), text(" ="), nest(2, cat(line, docOf(t.expr)))));
+    }
+    case Kind.DYNAMIC_EXPLORE:
+      return exploreDoc(e16);
+    case Kind.PARAM_INPUT:
+      return paramInputDoc(e16);
+    case Kind.NUMBER_LITERAL:
+      return text(e16.value);
+    case Kind.TEXT_LITERAL:
+      return text(quote(e16.value));
+    case Kind.TRUEFALSE_LITERAL:
+      return text(e16.value ? "true" : "false");
+    case Kind.NULL_LITERAL:
+      return text("null");
+    case Kind.DATETIME_LITERAL:
+      return text(datetimeText(e16.value));
+    case Kind.INTERVAL: {
+      let t = e16;
+      return cat(text("interval("), docOf(t.value), text(` ${t.unit})`));
+    }
+    case Kind.RANGE_LITERAL: {
+      let t = e16;
+      return text(`${t.start ?? ""}..${t.end ?? ""}`);
+    }
+    case Kind.TABLE_LITERAL:
+      return listDoc("[", "]", e16.rows.map((e17) => docOf(e17[0])));
+    default:
+      return text(e16.loc?.source ?? "");
+  }
+}
+function printProgram(e16, t = DEFAULT_WIDTH) {
+  return render(t, join(cat(text(";"), hardline), e16.exprs.map(docOf)));
+}
+function formatAql(e16, t = DEFAULT_WIDTH) {
+  if (!e16.trim())
+    return e16;
+  try {
+    return printProgram(parse(e16), t);
+  } catch {
+    return e16;
+  }
+}
+function createQueryInputError(e16, t) {
+  let n = Error(e16 ? `${e16}: ${t}` : t);
+  return n.name = "QueryInputError", n.path = e16, n;
+}
+function isQueryInputError(e16) {
+  return e16 instanceof Error && e16.name === "QueryInputError";
+}
+function applyQueryInput(e16, t, n) {
+  return printProgram(applyQueryInputToProgram(parse(e16), t, n));
+}
+function isEmpty$1(e16) {
+  return !e16.filters?.length && !e16.conditions?.length && !e16.sorts?.length && !e16.dateDrills?.length;
+}
+function applyQueryInputToProgram(e16, t, n) {
+  if (isEmpty$1(t))
+    return e16;
+  let r3 = e16.exprs.filter((e17) => e17.kind === Kind.DYNAMIC_EXPLORE);
+  if (r3.length !== 1)
+    throw createQueryInputError("", "Query Input can only be applied to a query with exactly one `explore { }` block.");
+  let [i] = r3, a = [], s3 = [];
+  (t.filters ?? []).forEach((e17, t3) => {
+    let { conditions: r4, aggregate: i3 } = filterToConditions(e17, `filters[${t3}]`, n);
+    (i3 ? s3 : a).push(...r4);
+  }), (t.conditions ?? []).forEach((e17, t3) => a.push(parseCondition(e17, `conditions[${t3}]`)));
+  let c3 = createDynamicExplore((t.dateDrills ?? []).reduce((e17, t3, n3) => applyDateDrill(e17, t3, `dateDrills[${n3}]`), i.dimensions), i.measures, [...i.filters, ...a], [...i.having, ...s3], i.relationships, i.options, i.params, t.sorts?.length ? toSorts(t.sorts, i) : i.sorts, i.loc);
+  return createProgram(e16.exprs.map((e17) => e17 === i ? c3 : e17), e16.loc);
+}
+function parseCondition(e16, t) {
+  let n = e16?.expr;
+  if (typeof n != "string" || !n.trim())
+    throw createQueryInputError(`${t}.expr`, "Expected an AQL condition.");
+  let r3;
+  try {
+    r3 = parse(n);
+  } catch (e17) {
+    throw createQueryInputError(`${t}.expr`, `Invalid AQL condition: ${e17.message}`);
+  }
+  let [i] = r3.exprs;
+  if (r3.exprs.length !== 1 || i.kind === Kind.DYNAMIC_EXPLORE || i.kind === Kind.FIELD_DECLARATION)
+    throw createQueryInputError(`${t}.expr`, "Expected a single AQL condition, not a query or declaration.");
+  return i;
+}
+function outputAliases(e16) {
+  let t = Array.isArray(e16.dimensions) ? e16.dimensions : [...e16.dimensions.rows, ...e16.dimensions.columns], n = /* @__PURE__ */ new Set;
+  for (let r3 of [...t, ...e16.measures])
+    r3.kind === Kind.NAMED_EXPRESSION && n.add(r3.name.value);
+  return n;
+}
+function toSorts(e16, t) {
+  let n = outputAliases(t);
+  return e16.map(({ field: e17, direction: t3 }, r3) => {
+    if (!n.has(e17)) {
+      let t4 = [...n].map((e18) => `\`${e18}\``).join(", ") || "none";
+      throw createQueryInputError(`sorts[${r3}].field`, `Unknown sort field \`${e17}\`: expected an output alias of the query (${t4}).`);
+    }
+    let i = typeof t3 == "string" ? t3.toLowerCase() : t3;
+    if (i !== "asc" && i !== "desc")
+      throw createQueryInputError(`sorts[${r3}].direction`, `Expected \`asc\` or \`desc\`, got ${JSON.stringify(t3)}.`);
+    return [createIdentifier(e17), i === "asc" ? OrderDirection.ASC : OrderDirection.DESC];
+  });
+}
+var DRILL_GRAINS = new Set([
+  "year",
+  "quarter",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute"
+]);
+function dottedName$1(e16) {
+  if (e16.kind === Kind.IDENTIFIER)
+    return e16.value;
+  if (e16.kind !== Kind.DOT_EXPRESSION)
+    return;
+  let t = e16, n = dottedName$1(t.left);
+  return n === undefined ? undefined : `${n}.${t.right.value}`;
+}
+function drilledField(e16) {
+  if (e16.kind === Kind.DOT_EXPRESSION)
+    return e16;
+  if (e16.kind === Kind.FUNCTION_CALL) {
+    let t = e16;
+    if (t.name.value === "date_trunc" && t.args.length === 2 && t.args[0].kind === Kind.DOT_EXPRESSION)
+      return t.args[0];
+  }
+  if (e16.kind === Kind.PIPE_EXPRESSION) {
+    let t = e16;
+    if (t.left.kind === Kind.DOT_EXPRESSION && DRILL_GRAINS.has(t.right.name.value) && t.right.args.length === 0)
+      return t.left;
+  }
+}
+function applyDateDrill(e16, t, n) {
+  let r3 = typeof t?.grain == "string" ? t.grain.trim().toLowerCase() : "";
+  if (!DRILL_GRAINS.has(r3))
+    throw createQueryInputError(`${n}.grain`, `Expected a grain (${[...DRILL_GRAINS].join(", ")}), got ${JSON.stringify(t?.grain)}.`);
+  let i = 0, a = (e17) => {
+    if (e17.kind !== Kind.NAMED_EXPRESSION)
+      return e17;
+    let n3 = e17, a3 = drilledField(n3.expr);
+    if (!a3 || dottedName$1(a3) !== t.field)
+      return e17;
+    i += 1;
+    let s4 = createFunctionCallExpression(createIdentifier("date_trunc"), [a3, createTextLiteral(r3)]);
+    return {
+      ...n3,
+      expr: s4
+    };
+  }, s3 = Array.isArray(e16) ? e16.map(a) : {
+    ...e16,
+    rows: e16.rows.map(a),
+    columns: e16.columns.map(a)
+  };
+  if (i === 0)
+    throw createQueryInputError(`${n}.field`, `No aliased dimension of the query is built directly on \`${t.field}\` to drill.`);
+  return s3;
+}
+var DATE_UNITS = new Set([
+  "year",
+  "quarter",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute"
+]);
+var UNSUPPORTED_OPERATORS = {
+  matches_user_attribute: "there are no user attributes to match against",
+  transform_pop_relative: "period-over-period comparison is not supported",
+  transform_pop_absolute: "period-over-period comparison is not supported",
+  transform_pop_none: "period-over-period comparison is not supported",
+  transform_date_drill: "send date drills as `dateDrills`, not as a filter"
+};
+var infix = (e16, t, n, r3 = false) => createInfixExpression(e16, createInfixOperatorToken(t, undefined, r3), n);
+function filterToConditions(e16, t, n) {
+  if (e16.operator === "none")
+    return {
+      conditions: [],
+      aggregate: false
+    };
+  if (e16.operator in UNSUPPORTED_OPERATORS)
+    throw createQueryInputError(`${t}.operator`, `Unsupported operator \`${e16.operator}\`: ${UNSUPPORTED_OPERATORS[e16.operator]}.`);
+  let r3, i = () => (r3 ??= resolveTarget(e16, t, n), r3), a = operatorToConditions(e16, t, i);
+  return {
+    conditions: a,
+    aggregate: a.length > 0 && i().aggregate
+  };
+}
+function operatorToConditions(e16, t, n) {
+  let { operator: r3 } = e16, i = e16.values ?? [], a = `${t}.values`, s3 = (e17) => {
+    if (i.length !== e17)
+      throw createQueryInputError(a, `Operator \`${r3}\` expects ${e17} value${e17 === 1 ? "" : "s"}, got ${i.length}.`);
+  }, c3 = (e17, t3) => literalFor(e17, i[t3], `${a}[${t3}]`), l3 = (e17, t3) => createTextLiteral(t3(String(i[e17]))), u = (e17, t3) => {
+    if (typeof e17 != "string" || !e17.trim())
+      throw createQueryInputError(t3, `Expected a date or date range, got ${JSON.stringify(e17)}.`);
+    return createDatetimeLiteral(e17.trim());
+  };
+  switch (r3) {
+    case "is":
+    case "is_not": {
+      if (i.length === 0)
+        throw createQueryInputError(a, `Operator \`${r3}\` expects at least 1 value.`);
+      let e17 = n(), t3 = r3 === "is_not";
+      return i.length === 1 ? [infix(e17.expr, Kind.IS_KEYWORD, c3(e17, 0), t3)] : [infix(e17.expr, Kind.IN_KEYWORD, createTableLiteral(i.map((t4, n3) => [c3(e17, n3)])), t3)];
+    }
+    case "is_null":
+    case "not_null":
+      return [infix(n().expr, Kind.IS_KEYWORD, createNullLiteral(), r3 === "not_null")];
+    case "is_true":
+    case "is_false":
+      return [infix(n().expr, Kind.IS_KEYWORD, createTruefalseLiteral(r3 === "is_true"))];
+    case "greater_than":
+    case "less_than": {
+      s3(1);
+      let e17 = n();
+      return [infix(e17.expr, r3 === "greater_than" ? Kind.GREATER_THAN : Kind.LESS_THAN, c3(e17, 0))];
+    }
+    case "between": {
+      s3(2);
+      let e17 = n();
+      if (e17.type === SqlType.DATE || e17.type === SqlType.DATETIME) {
+        let [t3, n3] = i.map((e18, t4) => {
+          if (typeof e18 != "string" || !e18.trim())
+            throw createQueryInputError(`${a}[${t4}]`, `Expected a date, got ${JSON.stringify(e18)}.`);
+          return e18.trim();
+        });
+        return [infix(e17.expr, Kind.MATCHES_KEYWORD, createDatetimeLiteral(`${t3} - ${n3}`))];
+      }
+      return [infix(e17.expr, Kind.GREATER_THAN_EQUAL, c3(e17, 0)), infix(e17.expr, Kind.LESS_THAN_EQUAL, c3(e17, 1))];
+    }
+    case "contains":
+    case "does_not_contain":
+      return s3(1), [infix(n().expr, Kind.ILIKE_KEYWORD, l3(0, (e17) => `%${e17}%`), r3 === "does_not_contain")];
+    case "starts_with":
+      return s3(1), [infix(n().expr, Kind.ILIKE_KEYWORD, l3(0, (e17) => `${e17}%`))];
+    case "ends_with":
+      return s3(1), [infix(n().expr, Kind.ILIKE_KEYWORD, l3(0, (e17) => `%${e17}`))];
+    case "matches":
+      return s3(1), [infix(n().expr, Kind.MATCHES_KEYWORD, u(i[0], `${a}[0]`))];
+    case "last":
+    case "next": {
+      s3(1);
+      let c4 = Number(i[0]);
+      if (!Number.isInteger(c4) || c4 < 0 || typeof i[0] == "boolean")
+        throw createQueryInputError(`${a}[0]`, `Expected a whole number of periods, got ${JSON.stringify(i[0])}.`);
+      let l4 = e16.modifier?.trim().toLowerCase().replace(/s$/, "");
+      if (!l4 || !DATE_UNITS.has(l4))
+        throw createQueryInputError(`${t}.modifier`, `Operator \`${r3}\` needs a date unit (${[...DATE_UNITS].join(", ")}), got ${JSON.stringify(e16.modifier)}.`);
+      return [infix(n().expr, Kind.MATCHES_KEYWORD, createDatetimeLiteral(`${r3} ${c4} ${l4}${c4 === 1 ? "" : "s"}`))];
+    }
+    case "before":
+    case "after":
+      return s3(1), [infix(n().expr, r3 === "before" ? Kind.LESS_THAN : Kind.GREATER_THAN, u(i[0], `${a}[0]`))];
+    default:
+      throw createQueryInputError(`${t}.operator`, `Unsupported operator \`${r3}\`.`);
+  }
+}
+function resolveTarget(e16, t, n) {
+  let r3 = `${t}.field`;
+  if (!e16.field?.includes(".")) {
+    if (e16.aggregation)
+      throw createQueryInputError(`${t}.aggregation`, "An aggregation applies to a dataset field (`model.field`), not to a metric.");
+    let i3 = e16.field ? n.store.getMayBeMetric(e16.field) : undefined;
+    if (!i3)
+      throw createQueryInputError(r3, `Unknown field \`${e16.field}\`: expected a dataset field as \`model.field\` or a dataset metric.`);
+    return {
+      expr: createIdentifier(i3.name),
+      type: i3.type,
+      name: i3.name,
+      aggregate: true
+    };
+  }
+  let { ref: i, field: a } = resolveField(e16.field, r3, n);
+  if (!e16.aggregation)
+    return {
+      expr: i,
+      type: a.type,
+      name: e16.field,
+      aggregate: false
+    };
+  let s3 = aggregationFunctionName(e16.aggregation);
+  if (!s3)
+    throw createQueryInputError(`${t}.aggregation`, `Unknown aggregation \`${e16.aggregation}\`.`);
+  let c3 = s3 === "min" || s3 === "max" ? a.type : SqlType.NUMBER;
+  return {
+    expr: createFunctionCallExpression(createIdentifier(s3), [i]),
+    type: c3,
+    name: `${s3}(${e16.field})`,
+    aggregate: true
+  };
+}
+function aggregationFunctionName(e16) {
+  let t = Object.entries(AggregationType).find(([, t3]) => t3 === e16.trim().toLowerCase());
+  if (!(!t || t[1] === AggregationType.CUSTOM))
+    return t[0].toLowerCase();
+}
+function resolveField(e16, t, n) {
+  let r3 = e16.lastIndexOf(".");
+  if (r3 <= 0 || r3 === e16.length - 1)
+    throw createQueryInputError(t, `Expected a dataset field as \`model.field\`, got \`${e16}\`.`);
+  let i = e16.slice(0, r3), a = e16.slice(r3 + 1), s3 = n.store.getMayBeModelField({
+    modelName: i,
+    fieldName: a
+  });
+  if (!s3)
+    throw createQueryInputError(t, `Unknown field \`${e16}\` in this dataset.`);
+  let c3 = i.split(".").map((e17) => createIdentifier(e17));
+  return {
+    ref: createDotExpression(c3.slice(1).reduce((e17, t3) => createDotExpression(e17, t3), c3[0]), createIdentifier(a)),
+    field: s3
+  };
+}
+function literalFor(e16, t, n) {
+  if (t === null)
+    return createNullLiteral();
+  switch (e16.type) {
+    case SqlType.NUMBER: {
+      let r3 = typeof t == "number" ? t : Number(t);
+      if (typeof t == "boolean" || t === "" || !Number.isFinite(r3))
+        throw createQueryInputError(n, `Expected a number for \`${e16.name}\`, got ${JSON.stringify(t)}.`);
+      return createNumberLiteral(String(r3));
+    }
+    case SqlType.TRUEFALSE:
+      if (t === true || t === "true")
+        return createTruefalseLiteral(true);
+      if (t === false || t === "false")
+        return createTruefalseLiteral(false);
+      throw createQueryInputError(n, `Expected true or false for \`${e16.name}\`, got ${JSON.stringify(t)}.`);
+    case SqlType.DATE:
+    case SqlType.DATETIME:
+      if (typeof t != "string" || !t.trim())
+        throw createQueryInputError(n, `Expected a date for \`${e16.name}\`, got ${JSON.stringify(t)}.`);
+      return createDatetimeLiteral(t.trim());
+    default:
+      return createTextLiteral(String(t));
+  }
+}
+var DATE_GRAINS = new Set([
+  "year",
+  "quarter",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute"
+]);
+function dottedName(e16) {
+  if (e16.kind === Kind.IDENTIFIER)
+    return e16.value;
+  if (e16.kind !== Kind.DOT_EXPRESSION)
+    return;
+  let t = e16, n = dottedName(t.left);
+  return n === undefined ? undefined : `${n}.${t.right.value}`;
+}
+function lookup(e16, t) {
+  let n = t.kind === Kind.DOT_EXPRESSION ? dottedName(t) : undefined;
+  if (!n)
+    return;
+  let r3 = n.lastIndexOf("."), i = n.slice(0, r3), a = n.slice(r3 + 1), s3 = e16.getMayBeModelField({
+    modelName: i,
+    fieldName: a
+  });
+  return s3 ? {
+    modelName: i,
+    fieldName: a,
+    field: s3
+  } : undefined;
+}
+function underlyingField(e16) {
+  if (e16.kind === Kind.FUNCTION_CALL) {
+    let t = e16;
+    if (t.name.value === "date_trunc" && t.args.length >= 1)
+      return t.args[0];
+  }
+  if (e16.kind === Kind.PIPE_EXPRESSION) {
+    let t = e16;
+    if (t.right.kind === Kind.FUNCTION_CALL && DATE_GRAINS.has(t.right.name.value) && t.right.args.length === 0)
+      return t.left;
+  }
+  return e16;
+}
+function aggregationName(e16) {
+  let t = AggregationType[e16.toUpperCase()];
+  return t && t !== AggregationType.CUSTOM ? t : undefined;
+}
+function aggregatedField(e16) {
+  let t = e16.kind === Kind.PIPE_EXPRESSION ? e16.right : e16;
+  if (t.kind !== Kind.FUNCTION_CALL)
+    return;
+  let n = t, r3 = aggregationName(n.name.value);
+  if (!(!r3 || n.args.length !== 1))
+    return {
+      aggregation: r3,
+      arg: n.args[0]
+    };
+}
+function adhoc(e16, t) {
+  return {
+    name: e16,
+    fieldName: e16,
+    label: e16,
+    adhoc: true,
+    isMeasure: t
+  };
+}
+function describeDimension(e16, t, n) {
+  let r3 = lookup(n, underlyingField(t));
+  return r3 ? {
+    name: e16,
+    fieldName: r3.fieldName,
+    modelId: r3.modelName,
+    label: r3.field.label ?? e16,
+    adhoc: false,
+    isMeasure: !!r3.field.aggregationType
+  } : adhoc(e16, false);
+}
+function describeMeasure(e16, t, n) {
+  if (t.kind === Kind.IDENTIFIER) {
+    let r4 = n.getMayBeMetric(t.value);
+    return r4 ? {
+      name: e16,
+      fieldName: r4.name,
+      label: r4.label ?? e16,
+      adhoc: false,
+      isMeasure: true
+    } : adhoc(e16, true);
+  }
+  let r3 = lookup(n, t);
+  if (r3)
+    return {
+      name: e16,
+      fieldName: r3.fieldName,
+      modelId: r3.modelName,
+      label: r3.field.label ?? e16,
+      adhoc: false,
+      isMeasure: true,
+      ...r3.field.aggregationType ? { aggregation: r3.field.aggregationType } : {}
+    };
+  let i = aggregatedField(t), a = i && lookup(n, i.arg);
+  return i && a ? {
+    name: e16,
+    fieldName: a.fieldName,
+    modelId: a.modelName,
+    label: e16,
+    adhoc: false,
+    isMeasure: true,
+    aggregation: i.aggregation
+  } : adhoc(e16, true);
+}
+function aliasOf(e16) {
+  if (e16.kind === Kind.NAMED_EXPRESSION) {
+    let t = e16;
+    return {
+      name: t.name.value,
+      expr: t.expr
+    };
+  }
+  if (e16.kind === Kind.DOT_EXPRESSION)
+    return {
+      name: e16.right.value,
+      expr: e16
+    };
+}
+function describeColumns(e16, t) {
+  let n = parse(e16).exprs.filter((e17) => e17.kind === Kind.DYNAMIC_EXPLORE);
+  if (n.length !== 1)
+    return;
+  let [r3] = n, i = Array.isArray(r3.dimensions) ? r3.dimensions : [...r3.dimensions.rows, ...r3.dimensions.columns], a = [];
+  for (let e17 of i) {
+    let n3 = aliasOf(e17);
+    n3 && a.push(describeDimension(n3.name, n3.expr, t.store));
+  }
+  for (let e17 of r3.measures) {
+    let n3 = aliasOf(e17);
+    n3 && a.push(describeMeasure(n3.name, n3.expr, t.store));
+  }
+  return a;
+}
 var RUBY_SQL_GEN_URL = "http://localhost:6341";
 var rubySqlBackend = {
   name: "ruby",
@@ -154492,17 +155326,17 @@ var import_lodash3 = __toESM(require_lodash(), 1);
 
 // src/commands/aml/validators/report.ts
 function offsetToLineColumn(content, offset) {
-  let line = 1;
+  let line2 = 1;
   let lineStart = 0;
   const end = Math.min(offset, content.length);
   for (let i = 0;i < end; i += 1) {
     if (content[i] === `
 `) {
-      line += 1;
+      line2 += 1;
       lineStart = i + 1;
     }
   }
-  return { line, column: offset - lineStart + 1 };
+  return { line: line2, column: offset - lineStart + 1 };
 }
 function errorToMessage(e16) {
   return { message: e16.message, code: e16.code, severity: "error" };
@@ -156169,7 +157003,7 @@ function parseGitignore(repoPath) {
   try {
     const content = fs19.readFileSync(gitignorePath, "utf-8");
     return content.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+`).map((line2) => line2.trim()).filter((line2) => line2.length > 0 && !line2.startsWith("#"));
   } catch {
     return [];
   }
@@ -156779,8 +157613,8 @@ function isArrayLike(input) {
 }
 function toLinesWithContent(input = "", trimmed2 = true, separator2 = `
 `) {
-  return input.split(separator2).reduce((output, line) => {
-    const lineContent = trimmed2 ? line.trim() : line;
+  return input.split(separator2).reduce((output, line2) => {
+    const lineContent = trimmed2 ? line2.trim() : line2;
     if (lineContent) {
       output.push(lineContent);
     }
@@ -156788,7 +157622,7 @@ function toLinesWithContent(input = "", trimmed2 = true, separator2 = `
   }, []);
 }
 function forEachLineWithContent(input, callback) {
-  return toLinesWithContent(input, true).map((line) => callback(line));
+  return toLinesWithContent(input, true).map((line2) => callback(line2));
 }
 function folderExists(path17) {
   return import_file_exists.exists(path17, import_file_exists.FOLDER);
@@ -156960,9 +157794,9 @@ var init_line_parser = __esm({
       constructor(regExp, useMatches) {
         this.matches = [];
         this.useMatches = useMatchesDefault;
-        this.parse = (line, target) => {
+        this.parse = (line2, target) => {
           this.resetMatches();
-          if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) {
+          if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line2(index)))) {
             return false;
           }
           return this.useMatches(target, this.prepareMatches()) !== false;
@@ -156978,8 +157812,8 @@ var init_line_parser = __esm({
       prepareMatches() {
         return this.matches;
       }
-      addMatch(reg, index, line) {
-        const matched = line && reg.exec(line);
+      addMatch(reg, index, line2) {
+        const matched = line2 && reg.exec(line2);
         if (matched) {
           this.pushMatch(index, matched);
         }
@@ -156990,8 +157824,8 @@ var init_line_parser = __esm({
       }
     };
     RemoteLineParser = class extends LineParser {
-      addMatch(reg, index, line) {
-        return /^remote:\s/.test(String(line)) && super.addMatch(reg, index, line);
+      addMatch(reg, index, line2) {
+        return /^remote:\s/.test(String(line2)) && super.addMatch(reg, index, line2);
       }
       pushMatch(index, matched) {
         if (index > 0 || matched.length > 1) {
@@ -157076,15 +157910,15 @@ function callTaskParser(parser4, streams) {
   return parser4(streams.stdOut, streams.stdErr);
 }
 function parseStringResponse(result, parsers12, texts, trim2 = true) {
-  asArray(texts).forEach((text) => {
-    for (let lines = toLinesWithContent(text, trim2), i3 = 0, max = lines.length;i3 < max; i3++) {
-      const line = (offset = 0) => {
+  asArray(texts).forEach((text2) => {
+    for (let lines = toLinesWithContent(text2, trim2), i3 = 0, max = lines.length;i3 < max; i3++) {
+      const line2 = (offset = 0) => {
         if (i3 + offset >= max) {
           return;
         }
         return lines[i3 + offset];
       };
-      parsers12.some(({ parse: parse2 }) => parse2(line, result));
+      parsers12.some(({ parse: parse2 }) => parse2(line2, result));
     }
   });
   return result;
@@ -157215,16 +158049,16 @@ var init_check_is_repo = __esm({
       }
       fail(error);
     };
-    parser = (text) => {
-      return text.trim() === "true";
+    parser = (text2) => {
+      return text2.trim() === "true";
     };
   }
 });
-function cleanSummaryParser(dryRun, text) {
+function cleanSummaryParser(dryRun, text2) {
   const summary = new CleanResponse(dryRun);
   const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;
-  toLinesWithContent(text).forEach((line) => {
-    const removed = line.replace(regexp, "");
+  toLinesWithContent(text2).forEach((line2) => {
+    const removed = line2.replace(regexp, "");
     summary.paths.push(removed);
     (isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);
   });
@@ -157280,8 +158114,8 @@ function straightThroughStringTask(commands, trimmed2 = false) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return trimmed2 ? String(text).trim() : text;
+    parser(text2) {
+      return trimmed2 ? String(text2).trim() : text2;
     }
   };
 }
@@ -157336,8 +158170,8 @@ function cleanTask(mode, customArgs) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return cleanSummaryParser(mode === "n", text);
+    parser(text2) {
+      return cleanSummaryParser(mode === "n", text2);
     }
   };
 }
@@ -157403,18 +158237,18 @@ var init_clean = __esm({
     ]);
   }
 });
-function configListParser(text) {
+function configListParser(text2) {
   const config = new ConfigList;
-  for (const item of configParser(text)) {
+  for (const item of configParser(text2)) {
     config.addValue(item.file, String(item.key), item.value);
   }
   return config;
 }
-function configGetParser(text, key) {
+function configGetParser(text2, key) {
   let value = null;
   const values2 = [];
   const scopes = /* @__PURE__ */ new Map;
-  for (const item of configParser(text, key)) {
+  for (const item of configParser(text2, key)) {
     if (item.key !== key) {
       continue;
     }
@@ -157435,18 +158269,18 @@ function configGetParser(text, key) {
 function configFilePath(filePath) {
   return filePath.replace(/^(file):/, "");
 }
-function* configParser(text, requestedKey = null) {
-  const lines = text.split("\x00");
+function* configParser(text2, requestedKey = null) {
+  const lines = text2.split("\x00");
   for (let i3 = 0, max = lines.length - 1;i3 < max; ) {
     const file = configFilePath(lines[i3++]);
     let value = lines[i3++];
     let key = requestedKey;
     if (value.includes(`
 `)) {
-      const line = splitOn(value, `
+      const line2 = splitOn(value, `
 `);
-      key = line[0];
-      value = line[1];
+      key = line2[0];
+      value = line2[1];
     }
     yield { file, key, value };
   }
@@ -157505,8 +158339,8 @@ function addConfigTask(key, value, append22, scope) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return text;
+    parser(text2) {
+      return text2;
     }
   };
 }
@@ -157518,8 +158352,8 @@ function getConfigTask(key, scope) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return configGetParser(text, key);
+    parser(text2) {
+      return configGetParser(text2, key);
     }
   };
 }
@@ -157531,8 +158365,8 @@ function listConfigTask(scope) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return configListParser(text);
+    parser(text2) {
+      return configListParser(text2);
     }
   };
 }
@@ -157592,10 +158426,10 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set;
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path17, line, preview] = input.split(NULL);
+    const [path17, line2, preview] = input.split(NULL);
     paths.add(path17);
     (results[path17] = results[path17] || []).push({
-      line: asNumber(line),
+      line: asNumber(line2),
       path: path17,
       preview
     });
@@ -158265,8 +159099,8 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path17, text) {
-  const response = String(text).trim();
+function parseInit(bare, path17, text2) {
+  const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
     return new InitSummary(bare, path17, false, result[1]);
@@ -158313,8 +159147,8 @@ function initTask(bare = false, path17, customArgs) {
   return {
     commands,
     format: "utf-8",
-    parser(text) {
-      return parseInit(commands.includes("--bare"), path17, text);
+    parser(text2) {
+      return parseInit(commands.includes("--bare"), path17, text2);
     }
   };
 }
@@ -158459,9 +159293,9 @@ var init_parse_diff_summary = __esm({
   }
 });
 function lineBuilder(tokens, fields) {
-  return fields.reduce((line, field, index) => {
-    line[field] = tokens[index] || "";
-    return line;
+  return fields.reduce((line2, field, index) => {
+    line2[field] = tokens[index] || "";
+    return line2;
   }, /* @__PURE__ */ Object.create({ diff: null }));
 }
 function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames, logFormat = "") {
@@ -158761,8 +159595,8 @@ var init_parse_remote_messages = __esm({
     init_utils();
     init_parse_remote_objects();
     parsers2 = [
-      new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text]) => {
-        result.remoteMessages.all.push(text.trim());
+      new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text2]) => {
+        result.remoteMessages.all.push(text2.trim());
         return false;
       }),
       ...remoteMessagesObjectParsers,
@@ -159041,8 +159875,8 @@ var init_FileStatusSummary = __esm({
     };
   }
 });
-function renamedFile(line) {
-  const [to4, from] = line.split(NULL);
+function renamedFile(line2) {
+  const [to4, from] = line2.split(NULL);
   return {
     from: from || to4,
     to: to4
@@ -159145,40 +159979,40 @@ var init_StatusSummary = __esm({
       ...conflicts("U", "A", "D", "U"),
       [
         "##",
-        (result, line) => {
+        (result, line2) => {
           const aheadReg = /ahead (\d+)/;
           const behindReg = /behind (\d+)/;
           const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
           const trackingReg = /\.{3}(\S*)/;
           const onEmptyBranchReg = /\son\s(\S+?)(?=\.{3}|$)/;
-          let regexResult = aheadReg.exec(line);
+          let regexResult = aheadReg.exec(line2);
           result.ahead = regexResult && +regexResult[1] || 0;
-          regexResult = behindReg.exec(line);
+          regexResult = behindReg.exec(line2);
           result.behind = regexResult && +regexResult[1] || 0;
-          regexResult = currentReg.exec(line);
+          regexResult = currentReg.exec(line2);
           result.current = filterType(regexResult?.[1], filterString, null);
-          regexResult = trackingReg.exec(line);
+          regexResult = trackingReg.exec(line2);
           result.tracking = filterType(regexResult?.[1], filterString, null);
-          regexResult = onEmptyBranchReg.exec(line);
+          regexResult = onEmptyBranchReg.exec(line2);
           if (regexResult) {
             result.current = filterType(regexResult?.[1], filterString, result.current);
           }
-          result.detached = /\(no branch\)/.test(line);
+          result.detached = /\(no branch\)/.test(line2);
         }
       ]
     ]);
-    parseStatusSummary = function(text) {
-      const lines = text.split(NULL);
+    parseStatusSummary = function(text2) {
+      const lines = text2.split(NULL);
       const status = new StatusSummary;
       for (let i3 = 0, l3 = lines.length;i3 < l3; ) {
-        let line = lines[i3++].trim();
-        if (!line) {
+        let line2 = lines[i3++].trim();
+        if (!line2) {
           continue;
         }
-        if (line.charAt(0) === "R") {
-          line += NULL + (lines[i3++] || "");
+        if (line2.charAt(0) === "R") {
+          line2 += NULL + (lines[i3++] || "");
         }
-        splitLine(status, line);
+        splitLine(status, line2);
       }
       return status;
     };
@@ -159196,8 +160030,8 @@ function statusTask(customArgs) {
   return {
     format: "utf-8",
     commands,
-    parser(text) {
-      return parseStatusSummary(text);
+    parser(text2) {
+      return parseStatusSummary(text2);
     }
   };
 }
@@ -159654,8 +160488,8 @@ function toPath(input) {
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
   "src/lib/responses/CheckIgnore.ts"() {
-    parseCheckIgnore = (text) => {
-      return text.split(/\n/g).map(toPath).filter(Boolean);
+    parseCheckIgnore = (text2) => {
+      return text2.split(/\n/g).map(toPath).filter(Boolean);
     };
   }
 });
@@ -159812,14 +160646,14 @@ var init_pull = __esm({
     init_utils();
   }
 });
-function parseGetRemotes(text) {
+function parseGetRemotes(text2) {
   const remotes = {};
-  forEach2(text, ([name]) => remotes[name] = { name });
+  forEach2(text2, ([name]) => remotes[name] = { name });
   return Object.values(remotes);
 }
-function parseGetRemotesVerbose(text) {
+function parseGetRemotesVerbose(text2) {
   const remotes = {};
-  forEach2(text, ([name, url2, purpose]) => {
+  forEach2(text2, ([name, url2, purpose]) => {
     if (!Object.hasOwn(remotes, name)) {
       remotes[name] = {
         name,
@@ -159832,8 +160666,8 @@ function parseGetRemotesVerbose(text) {
   });
   return Object.values(remotes);
 }
-function forEach2(text, handler) {
-  forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
+function forEach2(text2, handler) {
+  forEachLineWithContent(text2, (line2) => handler(line2.split(/\s+/)));
 }
 var init_GetRemoteSummary = __esm({
   "src/lib/responses/GetRemoteSummary.ts"() {
@@ -160000,8 +160834,8 @@ function tagListTask(customArgs = []) {
   return {
     format: "utf-8",
     commands: ["tag", "-l", ...customArgs],
-    parser(text) {
-      return parseTagList(text, hasCustomSort);
+    parser(text2) {
+      return parseTagList(text2, hasCustomSort);
     }
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holistics/cli-core",
   "type": "module",
-  "version": "2.3.30",
+  "version": "2.3.31",
   "bin": {
     "holistics": "./bin/holistics.js"
   },