vercel 59.0.0 → 59.1.4

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-KDYRLN6H.js

@@ -0,0 +1,18 @@
+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 {
+  truncateEnd
+} from "./chunk-VDJN4WKH.js";
+
+// src/util/output/ellipsis.ts
+function ellipsis(str, length) {
+  return truncateEnd(str, length, { omission: "\u2026" });
+}
+
+export {
+  ellipsis
+};

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

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

package/dist/chunks/{chunk-L6NIIAB7.js → chunk-LNVZ3T7X.js}

@@ -6,35 +6,33 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   writeProjectSettings
-} from "./chunk-N5DK7EMY.js";
+} from "./chunk-4HI7G6KG.js";
 import {
   autoInstallVercelPlugin
 } from "./chunk-HT2XWSAJ.js";
 import {
   stamp_default
 } from "./chunk-64IF634X.js";
-import {
-  ensureLink
-} from "./chunk-PBECT5BN.js";
 import {
   pullCommand
-} from "./chunk-SHR6DYA5.js";
+} from "./chunk-7NQLRE5V.js";
 import {
   help
-} from "./chunk-ZX2FSPWV.js";
+} from "./chunk-SJQEGGH7.js";
 import {
   VERCEL_DIR,
   VERCEL_DIR_PROJECT,
+  ensureLink,
   envPullCommandLogic,
   humanizePath,
   parseTarget
-} from "./chunk-3R5JGMHV.js";
+} from "./chunk-VE545BR3.js";
 import {
   TelemetryClient
 } from "./chunk-ECCWJHC6.js";
 import {
   printError
-} from "./chunk-KBEX5MYS.js";
+} from "./chunk-VAFU7DXZ.js";
 import {
   parseArguments
 } from "./chunk-XLKFJPMT.js";

package/dist/chunks/{chunk-UQVOFOP2.js → chunk-M34ZRNDQ.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_lib
-} from "./chunk-3R5JGMHV.js";
+} from "./chunk-VE545BR3.js";
 import {
   isNativeBinaryInstall
 } from "./chunk-ECCWJHC6.js";

package/dist/chunks/chunk-QCVKGY2A.js

@@ -0,0 +1,151 @@
+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 {
+  formatErrorJson,
+  handleApiError
+} from "./chunk-NM43FFV6.js";
+import {
+  isAPIError
+} from "./chunk-SOFC4MLS.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+
+// src/commands/metrics/schema-api.ts
+var OBSERVABILITY_METRICS_PATH = "/metrics/v1";
+var METRIC_CATALOG_PAGE_SIZE = 250;
+function toMetricDetail(metric) {
+  return {
+    id: metric.id,
+    description: metric.description,
+    dimensions: metric.dimensions,
+    unit: metric.unit,
+    aggregations: metric.aggregations,
+    defaultAggregation: metric.defaultAggregation
+  };
+}
+function getDefaultAggregation(detail, metricId) {
+  return detail.find((metric) => metric.id === metricId)?.defaultAggregation;
+}
+async function fetchMetricList(client, accountId) {
+  const { metrics } = await client.fetch(
+    "/v2/observability/schema",
+    { accountId }
+  );
+  return metrics;
+}
+async function fetchCustomMetricCatalog(client, accountId, search, activeSince) {
+  const metrics = [];
+  let cursor = null;
+  do {
+    const searchParams = new URLSearchParams({
+      limit: String(METRIC_CATALOG_PAGE_SIZE),
+      kind: "custom"
+    });
+    if (search) {
+      searchParams.set("search", search);
+    }
+    if (activeSince) {
+      searchParams.set("activeSince", activeSince);
+    }
+    if (cursor) {
+      searchParams.set("cursor", cursor);
+    }
+    const response = await client.fetch(
+      `${OBSERVABILITY_METRICS_PATH}?${searchParams}`,
+      { accountId }
+    );
+    metrics.push(
+      ...response.metrics.map((metric) => ({
+        id: metric.id,
+        description: metric.description,
+        dimensions: metric.dimensions,
+        unit: metric.unit,
+        aggregations: metric.aggregations
+      }))
+    );
+    cursor = response.pagination.hasMore ? response.pagination.nextCursor : null;
+  } while (cursor);
+  return metrics.filter(
+    (metric) => !metric.id.startsWith("vercel.") && (!search || metric.id.startsWith(search))
+  ).sort((left, right) => left.id.localeCompare(right.id));
+}
+async function fetchCustomMetricDetail(client, accountId, metricId) {
+  const metrics = await fetchCustomMetricCatalog(client, accountId, metricId);
+  const exactMetric = metrics.find((metric) => metric.id === metricId);
+  if (!exactMetric) {
+    return metrics;
+  }
+  return [exactMetric];
+}
+async function fetchMetricDetail(client, accountId, metricId) {
+  const detail = await client.fetch(
+    `/v2/observability/schema/${encodeURIComponent(metricId)}`,
+    { accountId }
+  );
+  return detail.map(toMetricDetail);
+}
+async function fetchSchemaOrExit(client, jsonOutput, operation) {
+  try {
+    return await operation();
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleApiError(err, jsonOutput, client, {
+        401: {
+          code: "SCHEMA_UNAUTHORIZED",
+          message: "The metrics schema API request was not authorized. Run `vercel login` to authenticate and `vercel switch` to select a team, then try again."
+        },
+        403: {
+          code: "SCHEMA_UNAUTHORIZED",
+          message: "The metrics schema API request was not authorized. Run `vercel login` to authenticate and `vercel switch` to select a team, then try again."
+        }
+      });
+    }
+    const message = err instanceof Error ? `Failed to fetch metrics schema: ${err.message}` : `Failed to fetch metrics schema: ${String(err)}`;
+    if (jsonOutput) {
+      client.stdout.write(formatErrorJson("SCHEMA_FETCH_FAILED", message));
+    } else {
+      output_manager_default.error(message);
+    }
+    return 1;
+  }
+}
+function fetchCustomMetricDetailOrExit(client, accountId, jsonOutput, metricId) {
+  return fetchSchemaOrExit(
+    client,
+    jsonOutput,
+    () => fetchCustomMetricDetail(client, accountId, metricId)
+  );
+}
+function fetchCombinedMetricListOrExit(client, accountId, jsonOutput) {
+  return fetchSchemaOrExit(client, jsonOutput, async () => {
+    const [platformMetrics, customMetrics] = await Promise.all([
+      fetchMetricList(client, accountId),
+      fetchCustomMetricCatalog(client, accountId).catch(() => [])
+    ]);
+    return [
+      ...platformMetrics.filter((metric) => metric.id.startsWith("vercel.")),
+      ...customMetrics.map(({ id, description }) => ({ id, description }))
+    ].sort((left, right) => left.id.localeCompare(right.id));
+  });
+}
+async function fetchMetricDetailOrExit(client, accountId, metricId, jsonOutput) {
+  return fetchSchemaOrExit(
+    client,
+    jsonOutput,
+    () => fetchMetricDetail(client, accountId, metricId)
+  );
+}
+
+export {
+  OBSERVABILITY_METRICS_PATH,
+  getDefaultAggregation,
+  fetchCustomMetricCatalog,
+  fetchCustomMetricDetailOrExit,
+  fetchCombinedMetricListOrExit,
+  fetchMetricDetailOrExit
+};

package/dist/chunks/{chunk-S3H7ITUR.js → chunk-QD5NX7RG.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   STANDARD_ENVIRONMENTS
-} from "./chunk-3R5JGMHV.js";
+} from "./chunk-VE545BR3.js";
 import {
   getCommandName,
   require_lib

package/dist/chunks/{chunk-4N7XLXM2.js → chunk-QQ6PH4RY.js}

@@ -73,6 +73,7 @@ var help = () => `
       flags                [cmd]       Manage feature flags for a Vercel project
       global-config        [cmd]       Manage Global Config stores
       httpstat             path        Visualize HTTP timing statistics for deployments
+      kms                  [cmd]       Manage KMS issuers, signing keys, and project grants [beta]
       logs                 [url]       Displays the logs for a deployment
       metrics              <metric>    Queries observability metrics for your project or team
       mcp                              Set up MCP agents and configuration

package/dist/chunks/{chunk-A5KP5HAI.js → chunk-RIB4S2IB.js}

@@ -19,11 +19,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"
 };
@@ -47,6 +55,7 @@ var imageLsSubcommand = {
       description: "Only list images that have no tags"
     },
     limitOption,
+    nextOption,
     cursorOption,
     formatOption,
     jsonOption