@depup/vercel 58.4.4-depup.0 → 59.1.3-depup.0

package/dist/chunks/{chunk-EBLH23AQ.js → chunk-F7OXZLY2.js}

@@ -12,10 +12,10 @@ import {
 } from "./chunk-FGDKMNEN.js";
 import {
   truncateMiddle
-} from "./chunk-RQ7H43CJ.js";
+} from "./chunk-VDJN4WKH.js";
 import {
   table
-} from "./chunk-KT4XXKJK.js";
+} from "./chunk-VAFU7DXZ.js";
 
 // src/commands/alerts/format.ts
 function renderAlertTable(rows, hsep = 3) {
@@ -65,21 +65,18 @@ function humanizeReference(value, opts = {}) {
     return opts.case === "title" ? label : label.toLowerCase();
   }).join(" / ");
 }
-function formatRuleScope(projectId, {
+function formatRuleScope(rule, {
   projectIdMaxLength = 48,
   filterMaxLength = 80
 } = {}) {
+  const { projectId } = rule;
   if (!projectId) {
     return "team-wide";
   }
-  const projectIdMatch = projectId.match(/^projectId eq '([^']+)'$/);
-  if (projectIdMatch?.[1]) {
-    return `project: ${truncateMiddle(projectIdMatch[1], projectIdMaxLength)}`;
-  }
-  if (!/\s/.test(projectId)) {
+  if (isCustomAlertRule(rule)) {
     return `project: ${truncateMiddle(projectId, projectIdMaxLength)}`;
   }
-  return `project filter: ${truncateMiddle(projectId, filterMaxLength)}`;
+  return truncateMiddle(projectId, filterMaxLength);
 }
 function isCustomAlertRule(rule) {
   return Boolean(rule.customAlert) || Boolean(

package/dist/chunks/{chunk-J6LK45HT.js → chunk-GFCTRJI5.js}

@@ -24,11 +24,19 @@ var projectScopeOption = {
   shorthand: "p",
   description: "Project name or ID (defaults to the linked project)."
 };
+var nextOption = {
+  name: "next",
+  shorthand: null,
+  type: String,
+  deprecated: false,
+  description: "Continue from a previous response",
+  argument: "CURSOR"
+};
 var cursorOption = {
   name: "cursor",
   shorthand: "c",
   type: String,
-  deprecated: false,
+  deprecated: true,
   description: "Cursor from a previous page to continue listing from",
   argument: "STRING"
 };
@@ -37,7 +45,13 @@ var permissionsLsSubcommand = {
   aliases: ["list"],
   description: "List teams with access to a repository",
   arguments: [],
-  options: [projectScopeOption, limitOption, cursorOption, formatOption],
+  options: [
+    projectScopeOption,
+    limitOption,
+    nextOption,
+    cursorOption,
+    formatOption
+  ],
   examples: [
     {
       name: "List teams with access to a repository",

package/dist/chunks/{chunk-V5P25P7F.js → chunk-GGPE5377.js}

@@ -4,19 +4,12 @@ import { dirname as __dirname_ } from 'node:path';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
-import {
-  require_source
-} from "./chunk-S7KYDPEM.js";
-import {
-  __toESM
-} from "./chunk-TZ2YI2VH.js";
 
-// src/util/output/highlight.ts
-var import_chalk = __toESM(require_source(), 1);
-function highlight(text) {
-  return import_chalk.default.bold.underline(text);
-}
+// src/util/constants.ts
+var SENTRY_DSN = void 0;
+var BUILD_LABEL = void 0;
 
 export {
-  highlight
+  SENTRY_DSN,
+  BUILD_LABEL
 };

package/dist/chunks/{chunk-4LDQIDRM.js → chunk-GMWRTZVZ.js}

@@ -83,13 +83,21 @@ var listSubcommand = {
       description: "unresolved (default), resolved, or all"
     },
     {
-      name: "page",
+      name: "page-path",
       shorthand: null,
       type: [String],
       argument: "PATH",
       deprecated: false,
       description: "Filter by recorded page path or glob (repeatable). Note: rewrites may record a different path than the browser URL"
     },
+    {
+      name: "page",
+      shorthand: null,
+      type: [String],
+      argument: "PATH",
+      deprecated: true,
+      description: "Filter by recorded page path or glob"
+    },
     {
       name: "author",
       shorthand: null,

package/dist/chunks/{chunk-NJUPUGOE.js → chunk-HT2XWSAJ.js}

@@ -173,7 +173,7 @@ async function isPluginInstalledForTarget(target) {
   return false;
 }
 async function confirm(client, message) {
-  if (!client.stdin.isTTY) {
+  if (client.nonInteractive || !client.stdin.isTTY) {
     return false;
   }
   return client.input.confirm(message, true);

package/dist/chunks/chunk-IKKUCZE7.js

@@ -0,0 +1,96 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  isJSONObject
+} from "./chunk-DAWJOQF6.js";
+import {
+  getProjectByNameOrId
+} from "./chunk-VE545BR3.js";
+import {
+  AGENT_REASON,
+  outputAgentError
+} from "./chunk-TJLBCLEX.js";
+import {
+  ProjectNotFound,
+  isAPIError
+} from "./chunk-SOFC4MLS.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+
+// src/commands/alerts/rules/custom-alert-query.ts
+async function resolveCustomAlertProjectName(client, scope, projectId) {
+  if (scope.projectId === projectId && scope.projectName) {
+    return scope.projectName;
+  }
+  try {
+    const project = await getProjectByNameOrId(client, projectId, scope.teamId);
+    return project instanceof ProjectNotFound ? void 0 : project.name;
+  } catch (error) {
+    if (isAPIError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function parseCustomAlertQueryBody(client, body) {
+  const customAlert = body.customAlert;
+  if (!isJSONObject(customAlert)) {
+    return void 0;
+  }
+  const queryJsonString = customAlert.queryJsonString;
+  if (typeof queryJsonString !== "string") {
+    return void 0;
+  }
+  let query;
+  try {
+    query = JSON.parse(queryJsonString);
+  } catch {
+    const message = "Invalid JSON in customAlert.queryJsonString.";
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message,
+        hint: "Provide queryJsonString as an escaped JSON string. Run `vercel alerts rules schema --type custom_alert` for examples."
+      },
+      1
+    );
+    output_manager_default.error(message);
+    return 1;
+  }
+  if (!isJSONObject(query)) {
+    return void 0;
+  }
+  return { customAlert, query };
+}
+function setMissingCustomAlertProjectScope(parsedQuery, teamId, projectId, projectName) {
+  const existingScope = parsedQuery.query.scope;
+  if (existingScope !== void 0 && !isJSONObject(existingScope)) {
+    return;
+  }
+  const projectScope = existingScope ?? {
+    type: "project",
+    ownerId: teamId,
+    projectIds: [projectId]
+  };
+  if (!Object.hasOwn(projectScope, "projectId")) {
+    projectScope.projectId = projectId;
+  }
+  if (projectName && !Object.hasOwn(projectScope, "projectName")) {
+    projectScope.projectName = projectName;
+  }
+  parsedQuery.query.scope = projectScope;
+  parsedQuery.customAlert.queryJsonString = JSON.stringify(parsedQuery.query);
+}
+
+export {
+  resolveCustomAlertProjectName,
+  parseCustomAlertQueryBody,
+  setMissingCustomAlertProjectScope
+};

package/dist/chunks/chunk-JKQWQA2T.js

@@ -0,0 +1,39 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  parseArguments
+} from "./chunk-XLKFJPMT.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/config/global-path.ts
+import path from "path";
+import * as config from "@vercel/cli-config";
+function getGlobalPathConfig2(argvSlice = process.argv.slice(2), cwd = process.cwd()) {
+  const args = parseArguments(argvSlice, {}, { permissive: true });
+  const confFlag = args.flags["--global-config"];
+  if (confFlag) {
+    return path.resolve(cwd, confFlag);
+  } else {
+    return config.getGlobalPathConfig();
+  }
+}
+
+// src/util/output/highlight.ts
+var import_chalk = __toESM(require_source(), 1);
+function highlight(text) {
+  return import_chalk.default.bold.underline(text);
+}
+
+export {
+  getGlobalPathConfig2 as getGlobalPathConfig,
+  highlight
+};

package/dist/chunks/{chunk-XIG4GH62.js → chunk-JYEO6OJS.js}

@@ -16,16 +16,16 @@ import {
 } from "./chunk-A3NYPUKZ.js";
 import {
   ellipsizeMiddle
-} from "./chunk-RQ7H43CJ.js";
+} from "./chunk-VDJN4WKH.js";
 import {
   elapsed
 } from "./chunk-VXYGCOKL.js";
-import {
-  table
-} from "./chunk-KT4XXKJK.js";
 import {
   require_ms
 } from "./chunk-GGP5R3FU.js";
+import {
+  table
+} from "./chunk-VAFU7DXZ.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";
@@ -125,26 +125,101 @@ function toGranularityMsFromDuration(duration) {
   return duration.days * DAY_MS;
 }
 
+// src/commands/metrics/types.ts
+var CANONICAL_AGGREGATIONS = [
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "p50",
+  "p75",
+  "p90",
+  "p95",
+  "p99"
+];
+function isCanonicalAggregation(aggregation) {
+  return CANONICAL_AGGREGATIONS.includes(aggregation);
+}
+
+// src/commands/metrics/metric-units.ts
+var DURATION_UNITS = /* @__PURE__ */ new Set([
+  "nanoseconds",
+  "microseconds",
+  "milliseconds",
+  "seconds",
+  "minutes",
+  "hours",
+  "days"
+]);
+function normalizeMetricUnit(unit) {
+  return unit.trim().toLowerCase().replace(/[_\s]+/g, " ");
+}
+function getPreferredCustomMetricAggregation(unit) {
+  const normalizedUnit = normalizeMetricUnit(unit);
+  if (DURATION_UNITS.has(normalizedUnit)) {
+    return "p75";
+  }
+  if (normalizedUnit === "percent") {
+    return "avg";
+  }
+  return "sum";
+}
+function getDefaultCustomMetricAggregation(unit, aggregations) {
+  const preferredAggregation = getPreferredCustomMetricAggregation(unit);
+  if (aggregations?.includes(preferredAggregation)) {
+    return preferredAggregation;
+  }
+  if (aggregations?.includes("sum")) {
+    return "sum";
+  }
+  return aggregations?.find(isCanonicalAggregation) ?? "sum";
+}
+
 // src/commands/metrics/text-output.ts
 var import_chalk = __toESM(require_source(), 1);
 var GROUP_KEY_DELIMITER = "";
 var MAX_SPARKLINE_LENGTH = 120;
-var COUNT_UNITS = /* @__PURE__ */ new Set(["count", "usd", "us dollars", "dollars"]);
-var DURATION_UNITS = /* @__PURE__ */ new Set(["milliseconds", "seconds"]);
-var BYTES_UNITS = /* @__PURE__ */ new Set([
-  "bytes",
-  "megabytes",
-  "gigabyte hour",
-  "gigabyte_hour",
-  "gigabyte hours",
-  "gigabyte_hours"
-]);
-var RATIO_UNITS = /* @__PURE__ */ new Set(["ratio", "percent"]);
+var DURATION_SCALE_MS = {
+  seconds: 1e3,
+  minutes: 6e4,
+  hours: 36e5,
+  days: 864e5
+};
+var BYTE_SCALE = {
+  bytes: 1,
+  kilobytes: 1e3,
+  megabytes: 1e6,
+  gigabytes: 1e9,
+  terabytes: 1e12,
+  petabytes: 1e15
+};
+var COMPACT_NUMBER_FORMATTER = new Intl.NumberFormat("en-US", {
+  notation: "compact",
+  compactDisplay: "short"
+});
+var TWO_FRACTION_NUMBER_FORMATTER = new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 2
+});
+var TWO_SIGNIFICANT_NUMBER_FORMATTER = new Intl.NumberFormat("en-US", {
+  minimumSignificantDigits: 2,
+  maximumSignificantDigits: 2,
+  maximumFractionDigits: 2
+});
+var PERCENTAGE_FORMATTER = new Intl.NumberFormat("en-US", {
+  style: "unit",
+  unit: "percent",
+  unitDisplay: "narrow",
+  maximumFractionDigits: 1
+});
+var USD_FORMATTER = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
 var BLOCKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
 var MISSING_CHAR = "\xB7";
-function normalizeUnit(unit) {
-  return unit.trim().toLowerCase().replace(/[_\s]+/g, " ");
-}
 function isAggregationWithDimension(aggregation) {
   const [, dimension] = aggregation.split("/");
   return Boolean(dimension);
@@ -180,36 +255,8 @@ function formatPeriodSpan(startInput, endInput) {
   }
   return elapsed(durationMs);
 }
-function formatUnitLabel(unit) {
-  switch (normalizeUnit(unit)) {
-    case "milliseconds":
-      return "ms";
-    case "seconds":
-      return "s";
-    case "usd":
-    case "us dollars":
-      return "USD";
-    case "gigabyte hour":
-    case "gigabyte hours":
-      return "GB-h";
-    default:
-      return unit;
-  }
-}
-function isCountIntegerDisplay(measureType, aggregation) {
-  return measureType === "count" && aggregation === "sum";
-}
-function formatNumber(value, measureType, aggregation, opts) {
-  if (isCountIntegerDisplay(measureType, aggregation)) {
-    if (opts?.preserveFractionalCountSum && !Number.isInteger(value)) {
-      return formatDecimal(value);
-    }
-    return formatCount(value);
-  }
-  return formatDecimal(value);
-}
 function getStatColumns(aggregation) {
-  if (aggregation === "sum") {
+  if (aggregation === "sum" || aggregation === "count") {
     return ["total", "avg", "min", "max"];
   }
   return ["avg", "min", "max"];
@@ -250,13 +297,13 @@ function normalizeTimestampToIso(timestamp) {
   }
   return new Date(parsed).toISOString();
 }
-function formatStatCell(column, stats, measureType, aggregation, periodStart, periodEnd) {
+function formatStatCell(column, stats, periodStart, periodEnd, formatValue) {
   switch (column) {
     case "total":
-      return formatNumber(stats.total, measureType, aggregation);
+      return formatValue(stats.total);
     case "avg":
-      return formatNumber(stats.avg, measureType, aggregation, {
-        preserveFractionalCountSum: true
+      return formatValue(stats.avg, {
+        preserveFractionalCount: true
       });
     case "min": {
       const ts = formatMinMaxTimestamp(
@@ -264,7 +311,7 @@ function formatStatCell(column, stats, measureType, aggregation, periodStart, pe
         periodStart,
         periodEnd
       );
-      return `${formatNumber(stats.min.value, measureType, aggregation)} at ${ts}`;
+      return `${formatValue(stats.min.value)} at ${ts}`;
     }
     case "max": {
       const ts = formatMinMaxTimestamp(
@@ -272,7 +319,7 @@ function formatStatCell(column, stats, measureType, aggregation, periodStart, pe
         periodStart,
         periodEnd
       );
-      return `${formatNumber(stats.max.value, measureType, aggregation)} at ${ts}`;
+      return `${formatValue(stats.max.value)} at ${ts}`;
     }
   }
 }
@@ -312,22 +359,6 @@ function buildSeriesTimestamps(periodStart, periodEnd, granularityMs, observedTi
   }
   return buildObservedTimestamps(observedTimestamps, granularityMs);
 }
-function getMeasureType(unit) {
-  const normalized = normalizeUnit(unit);
-  if (COUNT_UNITS.has(normalized)) {
-    return "count";
-  }
-  if (DURATION_UNITS.has(normalized)) {
-    return "duration";
-  }
-  if (BYTES_UNITS.has(normalized)) {
-    return "bytes";
-  }
-  if (RATIO_UNITS.has(normalized)) {
-    return "ratio";
-  }
-  return "ratio";
-}
 function formatCount(n) {
   return Math.round(n).toLocaleString("en-US");
 }
@@ -349,6 +380,88 @@ function formatDecimal(n) {
   const trimmed = fixed.replace(/(\.\d*?[1-9])0+$/, "$1").replace(/\.0+$/, "").replace(/\.$/, "");
   return `${sign}${trimmed}`;
 }
+function formatDuration(durationMs) {
+  const durationSeconds = durationMs / 1e3;
+  if (durationMs < 1e3) {
+    return `${durationMs.toFixed(0)}ms`;
+  }
+  if (durationMs < 5e3) {
+    return `${Math.round(durationSeconds * 100) / 100}s`;
+  }
+  if (durationSeconds < 60) {
+    return `${durationSeconds.toFixed(0)}s`;
+  }
+  if (durationSeconds < 3600) {
+    return `${(durationSeconds / 60).toFixed(0)}m`;
+  }
+  return `${(durationSeconds / 3600).toFixed(0)}h`;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const units = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const absoluteBytes = Math.abs(bytes);
+  let unitIndex = Math.min(
+    units.length - 1,
+    Math.max(0, Math.floor(Math.log(absoluteBytes) / Math.log(1e3)))
+  );
+  let value = bytes / 1e3 ** unitIndex;
+  if (unitIndex === 1 || unitIndex === 2) {
+    value = Math.round(value);
+    if (Math.abs(value) === 1e3 && unitIndex < units.length - 1) {
+      value /= 1e3;
+      unitIndex += 1;
+    }
+  }
+  return `${TWO_FRACTION_NUMBER_FORMATTER.format(value)} ${units[unitIndex]}`;
+}
+function formatMetricValue(value, baseUnit, aggregation, opts) {
+  const formatCountValue = () => opts?.preserveFractionalCount && !Number.isInteger(value) ? formatDecimal(value) : formatCount(value);
+  if (isAggregationWithDimension(aggregation) || aggregation === "count") {
+    return formatCountValue();
+  }
+  const unit = normalizeMetricUnit(baseUnit ?? "units");
+  if (aggregation === "percent" || unit === "percent") {
+    return PERCENTAGE_FORMATTER.format(value);
+  }
+  if (aggregation === "unique") {
+    return COMPACT_NUMBER_FORMATTER.format(value);
+  }
+  const withRateSuffix = (formatted2) => aggregation === "persecond" ? `${formatted2}/s` : formatted2;
+  if (unit === "milliseconds") {
+    return withRateSuffix(formatDuration(value));
+  }
+  const durationScale = DURATION_SCALE_MS[unit];
+  if (durationScale) {
+    return withRateSuffix(formatDuration(value * durationScale));
+  }
+  if (unit === "nanoseconds" || unit === "microseconds") {
+    const suffix = unit === "nanoseconds" ? " ns" : " \xB5s";
+    const formatted2 = TWO_FRACTION_NUMBER_FORMATTER.format(value);
+    return withRateSuffix(`${formatted2}${suffix}`);
+  }
+  const byteScale = BYTE_SCALE[unit];
+  if (byteScale) {
+    return withRateSuffix(formatBytes(value * byteScale));
+  }
+  if (unit === "gigabyte hour" || unit === "gigabyte hours") {
+    const formatted2 = TWO_SIGNIFICANT_NUMBER_FORMATTER.format(value);
+    return withRateSuffix(`${formatted2} GB-hrs`);
+  }
+  if (unit === "usd" || unit === "us dollars" || unit === "dollars") {
+    return withRateSuffix(USD_FORMATTER.format(value));
+  }
+  if (unit === "count" && aggregation === "sum") {
+    return formatCountValue();
+  }
+  const formatted = COMPACT_NUMBER_FORMATTER.format(value);
+  const unitLabel = baseUnit?.trim();
+  if (!unitLabel || unit === "units" || unit === "count" || unit === "ratio") {
+    return withRateSuffix(formatted);
+  }
+  return withRateSuffix(`${formatted} ${unitLabel}`);
+}
 function formatMinMaxTimestamp(date, periodStart, periodEnd) {
   const sameDay = periodStart.getUTCFullYear() === periodEnd.getUTCFullYear() && periodStart.getUTCMonth() === periodEnd.getUTCMonth() && periodStart.getUTCDate() === periodEnd.getUTCDate();
   if (sameDay) {
@@ -542,9 +655,6 @@ function formatMetadataHeader(opts) {
       value: `${opts.teamName ?? opts.scope.ownerId} (all projects)`
     });
   }
-  if (opts.unit && normalizeUnit(opts.unit) !== "count") {
-    rows.push({ key: "Units", value: formatUnitLabel(opts.unit) });
-  }
   if (!opts.compact && typeof opts.groupCount === "number") {
     rows.push({ key: "Groups", value: String(opts.groupCount) });
   }
@@ -568,10 +678,9 @@ function formatSummaryTable(opts) {
         (column) => formatStatCell(
           column,
           row.stats,
-          opts.measureType,
-          opts.aggregation,
           opts.periodStart,
-          opts.periodEnd
+          opts.periodEnd,
+          opts.formatValue
         )
       )
     );
@@ -617,33 +726,9 @@ function formatSparklineSection(groupRows, sparklines, groupByFields, compact =
   return compact ? chart : `sparklines:
 ${chart}`;
 }
-function getEffectiveDisplay(baseUnit, aggregation) {
-  if (isAggregationWithDimension(aggregation)) {
-    return { displayUnit: void 0, measureType: "count" };
-  }
-  switch (aggregation) {
-    case "percent":
-      return { displayUnit: "%", measureType: "ratio" };
-    case "persecond": {
-      const label = baseUnit ? formatUnitLabel(baseUnit) : void 0;
-      return {
-        displayUnit: label ? `${label}/s` : void 0,
-        measureType: getMeasureType(baseUnit ?? "ratio")
-      };
-    }
-    default:
-      return {
-        displayUnit: baseUnit,
-        measureType: getMeasureType(baseUnit ?? "ratio")
-      };
-  }
-}
 function formatText(response, opts) {
   const rollupColumn = getRollupColumnName(opts.metric, opts.aggregation);
-  const { displayUnit, measureType } = getEffectiveDisplay(
-    opts.metricUnit,
-    opts.aggregation
-  );
+  const formatValue = (value, formatOptions) => formatMetricValue(value, opts.metricUnit, opts.aggregation, formatOptions);
   const granularityMs = toGranularityMsFromDuration(opts.granularity);
   const orderMetadata = getResolvedOrderMetadata(opts, response);
   const { groups, series, groupValues } = extractGroupedSeries(
@@ -674,7 +759,6 @@ function formatText(response, opts) {
     scope: opts.scope,
     projectName: opts.projectName,
     teamName: opts.teamName,
-    unit: displayUnit,
     groupCount: opts.groupBy.length > 0 ? groups.length : void 0,
     compact: opts.presentation?.compact
   });
@@ -705,10 +789,10 @@ No data found for this period.
   const summaryTable = formatSummaryTable({
     rows: summaryRows,
     groupByFields: opts.groupBy,
-    measureType,
     aggregation: opts.aggregation,
     periodStart: new Date(opts.periodStart),
     periodEnd: new Date(opts.periodEnd),
+    formatValue,
     ansiAwareGroupValues: opts.presentation?.compact
   });
   const groupedOutput = opts.groupBy.length > 0;
@@ -726,5 +810,7 @@ No data found for this period.
 export {
   computeGranularity,
   toGranularityMsFromDuration,
+  isCanonicalAggregation,
+  getDefaultCustomMetricAggregation,
   formatText
 };

package/dist/chunks/{chunk-HSYF5SI3.js → chunk-KTLFN5FV.js}

@@ -8,7 +8,7 @@ import {
   formatCondition,
   formatTransform,
   isTargetTransform
-} from "./chunk-4BUPRO5B.js";
+} from "./chunk-ZUVJISHS.js";
 import {
   output_manager_default
 } from "./chunk-OX7KI3LF.js";