vercel 50.25.6 → 50.26.0

package/dist/chunks/{chunk-VI7C4DUA.js → chunk-3AVNF6AH.js}

@@ -6,10 +6,10 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_end_of_stream
-} from "./chunk-RTWSSVAZ.js";
+} from "./chunk-YTTWXN4B.js";
 import {
   require_once
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   require_signal_exit
 } from "./chunk-I2CIWYG5.js";

package/dist/chunks/{chunk-XHQKUIYD.js → chunk-4IS2QZ7D.js}

@@ -6,10 +6,10 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   VERCEL_DIR
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   ConflictingConfigFiles
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 import {
   output_manager_default
 } from "./chunk-I2CIWYG5.js";

package/dist/chunks/{chunk-CNPRAFKN.js → chunk-5F2QN5D6.js}

@@ -7,7 +7,7 @@ const __dirname = __dirname_(__filename);
 import {
   formatOption,
   packageName
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 
 // src/commands/metrics/command.ts
 var schemaSubcommand = {

package/dist/chunks/chunk-6PXAVV2L.js

@@ -0,0 +1,127 @@
+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 {
+  formatOption,
+  limitOption,
+  nextOption,
+  packageName
+} from "./chunk-YRWIOAB2.js";
+
+// src/commands/activity/command.ts
+var typesSubcommand = {
+  name: "types",
+  aliases: [],
+  description: "List available event types with descriptions.",
+  arguments: [],
+  options: [formatOption],
+  examples: [
+    {
+      name: "List all event types",
+      value: `${packageName} activity types`
+    },
+    {
+      name: "Output JSON",
+      value: `${packageName} activity types --format json`
+    }
+  ]
+};
+var activityCommand = {
+  name: "activity",
+  aliases: [],
+  description: "List user activity events.",
+  arguments: [],
+  subcommands: [
+    // Hidden placeholder so the help synopsis renders [command] as optional
+    // (help.ts treats `command` as required unless a subcommand has `default: true`)
+    {
+      name: "ls",
+      aliases: ["list"],
+      description: "",
+      default: true,
+      hidden: true,
+      arguments: [],
+      options: [],
+      examples: []
+    },
+    typesSubcommand
+  ],
+  options: [
+    {
+      name: "type",
+      shorthand: null,
+      type: [String],
+      argument: "TYPE",
+      deprecated: false,
+      description: "Filter by event type. Repeatable and comma-separated (e.g. --type deployment --type project-created or --type deployment,project-created)."
+    },
+    {
+      name: "since",
+      shorthand: null,
+      type: String,
+      argument: "DATE",
+      deprecated: false,
+      description: "Show events after this date (ISO 8601 or relative: 1d, 7d, 30d)."
+    },
+    {
+      name: "until",
+      shorthand: null,
+      type: String,
+      argument: "DATE",
+      deprecated: false,
+      description: "Show events before this date (ISO 8601 or relative)."
+    },
+    {
+      name: "project",
+      shorthand: "p",
+      type: String,
+      argument: "NAME_OR_ID",
+      deprecated: false,
+      description: "Filter by project (overrides auto-detected linked project)."
+    },
+    {
+      name: "all",
+      shorthand: "a",
+      type: Boolean,
+      deprecated: false,
+      description: "Show all team events (ignore linked project auto-scoping)."
+    },
+    limitOption,
+    nextOption,
+    formatOption
+  ],
+  examples: [
+    {
+      name: "List events for the linked project",
+      value: `${packageName} activity`
+    },
+    {
+      name: "Filter events by multiple types",
+      value: `${packageName} activity --type deployment --type project-created --since 7d`
+    },
+    {
+      name: "Filter events by comma-separated types",
+      value: `${packageName} activity --type deployment,project-created --since 7d`
+    },
+    {
+      name: "List all team events",
+      value: `${packageName} activity --all --since 30d`
+    },
+    {
+      name: "Output JSON",
+      value: `${packageName} activity --format json | jq '.events[]'`
+    },
+    {
+      name: "List activity event types",
+      value: `${packageName} activity types`
+    }
+  ]
+};
+
+export {
+  typesSubcommand,
+  activityCommand
+};

package/dist/chunks/{chunk-R3ZVBJJV.js → chunk-7D2CONKL.js}

@@ -7,10 +7,10 @@ const __dirname = __dirname_(__filename);
 import {
   getTeamById,
   getUser
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   TeamDeleted
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 
 // src/util/get-scope.ts
 async function getScope(client, opts = {}) {

package/dist/chunks/chunk-7EHTK7LP.js

@@ -0,0 +1,359 @@
+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 {
+  __commonJS,
+  __require
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/pluralize@7.0.0/node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "../../node_modules/.pnpm/pluralize@7.0.0/node_modules/pluralize/pluralize.js"(exports, module) {
+    (function(root, pluralize) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize();
+        });
+      } else {
+        root.pluralize = pluralize();
+      }
+    })(exports, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token)
+          return token;
+        if (word === word.toUpperCase())
+          return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word))
+            return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token))
+            return true;
+          if (replaceMap.hasOwnProperty(token))
+            return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize.addPluralRule(word, "$0");
+        pluralize.addSingularRule(word, "$0");
+      };
+      pluralize.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["whiskey", "whiskies"]
+      ].forEach(function(rule) {
+        return pluralize.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|tlas|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[emjzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|octop|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/(m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/(m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|tlas|gas|(?:her|at|gr)o|ris)(?:es)?$/i, "$1"],
+        [/(analy|ba|diagno|parenthe|progno|synop|the|empha|cri)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|octop|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "alcohol",
+        "ammo",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "manga",
+        "news",
+        "pike",
+        "plankton",
+        "pliers",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transporation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize.addUncountableRule);
+      return pluralize;
+    });
+  }
+});
+
+export {
+  require_pluralize
+};

package/dist/chunks/{chunk-WUMIOXFA.js → chunk-AUOVKSJV.js}

@@ -6,13 +6,13 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   getLinkedProject
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   getCommandName,
   getFlagsSpecification,
   parseArguments,
   printError
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 import {
   output_manager_default
 } from "./chunk-I2CIWYG5.js";

package/dist/chunks/{chunk-MR7XLQML.js → chunk-BR67OKRE.js}

@@ -6,12 +6,12 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   VERCEL_DIR
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   ConflictingConfigFiles,
   InvalidLocalConfig,
   getArgs
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 
 // src/util/config/local-path.ts
 import path from "path";

package/dist/chunks/chunk-D63ZY6XZ.js

@@ -0,0 +1,38 @@
+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 {
+  require_ms
+} from "./chunk-CO5D46AG.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/time-utils.ts
+var import_ms = __toESM(require_ms(), 1);
+function parseTimeFlag(input) {
+  const milliseconds = (0, import_ms.default)(input);
+  if (milliseconds !== void 0) {
+    return new Date(Date.now() - milliseconds);
+  }
+  const date = new Date(input);
+  if (isNaN(date.getTime())) {
+    throw new Error(
+      `Invalid time format "${input}". Use relative (1h, 30m, 2d, 1w) or ISO 8601 datetime.`
+    );
+  }
+  return date;
+}
+function resolveTimeRange(since = "1h", until) {
+  const startTime = parseTimeFlag(since);
+  const endTime = until ? parseTimeFlag(until) : /* @__PURE__ */ new Date();
+  return { startTime, endTime };
+}
+
+export {
+  parseTimeFlag,
+  resolveTimeRange
+};

package/dist/chunks/{chunk-JTUKNHUL.js → chunk-DOMJ6XOD.js}

@@ -6,10 +6,10 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_lib
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   packageName
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 import {
   __toESM
 } from "./chunk-TZ2YI2VH.js";

package/dist/chunks/{chunk-IRQ6FO7P.js → chunk-DZ375AUF.js}

@@ -6,11 +6,11 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   getEnvTargetPlaceholder
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   packageName,
   yesOption
-} from "./chunk-6AFO56VB.js";
+} from "./chunk-YRWIOAB2.js";
 
 // src/commands/build/command.ts
 var buildCommand = {

package/dist/chunks/{chunk-P2UUUDM7.js → chunk-EFQYD7RX.js}

@@ -8,7 +8,7 @@ import {
   VERCEL_DIR,
   VERCEL_DIR_PROJECT,
   require_lib
-} from "./chunk-TQJBKJCP.js";
+} from "./chunk-XZTNWCFJ.js";
 import {
   require_dist
 } from "./chunk-I2CIWYG5.js";

package/dist/chunks/{chunk-I63FYLJU.js → chunk-EOZFDJSY.js}

@@ -5,12 +5,6 @@ const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 
-// src/util/is-valid-name.ts
-function isValidName(name = "") {
-  const blacklist = ":/#?&@%+~".split("");
-  return !name.split("").every((c) => blacklist.includes(c));
-}
-
 // src/util/get-command-flags.ts
 function getCommandFlags(argv, excludeFlags = []) {
   const flags = Object.keys(argv).filter((key) => !excludeFlags.includes(key)).map(
@@ -20,6 +14,5 @@ function getCommandFlags(argv, excludeFlags = []) {
 }
 
 export {
-  isValidName,
   getCommandFlags
 };