@uipath/function-tool 1.205.0-preview.277 → 1.206.0-preview.279

package/dist/{packager-tool-f7enb48c.js → packager-tool-cmtxbmhx.js}

@@ -1,11 +1,9 @@
 import {
-  getFileSystem
-} from "./packager-tool-y4vgqz1w.js";
-import {
+  __toESM,
   __commonJS,
-  __require,
-  __toESM
-} from "./packager-tool-1de529jm.js";
+  __exportCjs,
+  __require
+} from "./packager-tool-epsr41wx.js";
 
 // ../../node_modules/commander/lib/error.js
 var require_error = __commonJS(function(exports) {
@@ -127,7 +125,7 @@ var require_help = __commonJS(function(exports) {
       this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
     }
     visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
       const helpCommand = cmd._getHelpCommand();
       if (helpCommand && !helpCommand._hidden) {
         visibleCommands.push(helpCommand);
@@ -607,8 +605,8 @@ var require_option = __commonJS(function(exports) {
     }
   }
   function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
+    return str.split("-").reduce((str, word) => {
+      return str + word[0].toUpperCase() + word.slice(1);
     });
   }
   function splitOptionFlags(flags) {
@@ -1179,44 +1177,44 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       return source;
     }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
+    _prepareUserArgs(argv2, parseOptions) {
+      if (argv2 !== undefined && !Array.isArray(argv2)) {
         throw new Error("first parameter to parse must be array or undefined");
       }
       parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
+      if (argv2 === undefined && parseOptions.from === undefined) {
         if (process2.versions?.electron) {
           parseOptions.from = "electron";
         }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+        const execArgv2 = process2.execArgv ?? [];
+        if (execArgv2.includes("-e") || execArgv2.includes("--eval") || execArgv2.includes("-p") || execArgv2.includes("--print")) {
           parseOptions.from = "eval";
         }
       }
-      if (argv === undefined) {
-        argv = process2.argv;
+      if (argv2 === undefined) {
+        argv2 = process2.argv;
       }
-      this.rawArgs = argv.slice();
+      this.rawArgs = argv2.slice();
       let userArgs;
       switch (parseOptions.from) {
         case undefined:
         case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
+          this._scriptPath = argv2[1];
+          userArgs = argv2.slice(2);
           break;
         case "electron":
           if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
+            this._scriptPath = argv2[1];
+            userArgs = argv2.slice(2);
           } else {
-            userArgs = argv.slice(1);
+            userArgs = argv2.slice(1);
           }
           break;
         case "user":
-          userArgs = argv.slice(0);
+          userArgs = argv2.slice(0);
           break;
         case "eval":
-          userArgs = argv.slice(1);
+          userArgs = argv2.slice(1);
           break;
         default:
           throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
@@ -1739,18 +1737,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.error(message, { code: "commander.missingMandatoryOptionValue" });
     }
     _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
+      const findBestOptionFromValue = (option) => {
+        const optionKey = option.attributeName();
         const optionValue = this.getOptionValue(optionKey);
         const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
         const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
         if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
           return negativeOption;
         }
-        return positiveOption || option2;
+        return positiveOption || option;
       };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
+      const getErrorMessage = (option) => {
+        const bestOption = findBestOptionFromValue(option);
         const optionKey = bestOption.attributeName();
         const source = this.getOptionValueSource(optionKey);
         if (source === "env") {
@@ -1904,10 +1902,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this._name = path.basename(filename, path.extname(filename));
       return this;
     }
-    executableDir(path2) {
-      if (path2 === undefined)
+    executableDir(path) {
+      if (path === undefined)
         return this._executableDir;
-      this._executableDir = path2;
+      this._executableDir = path;
       return this;
     }
     helpInformation(contextOptions) {
@@ -2004,11 +2002,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
+      let exitCode2 = Number(process2.exitCode ?? 0);
+      if (exitCode2 === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode2 = 1;
       }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
+      this._exit(exitCode2, "commander.help", "(outputHelp)");
     }
     addHelpText(position, text) {
       const allowedValues = ["beforeAll", "before", "after", "afterAll"];
@@ -2080,246 +2078,717 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// ../../node_modules/commander/index.js
-var require_commander = __commonJS(function(exports) {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
+// ../filesystem/src/node.ts
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+var HASH_CHUNK_BYTES = 256 * 1024;
+var hashBuffers = [];
+var HASH_BUFFERS_KEPT = 64;
 
-// ../common/src/telemetry/pseudonymize.ts
-var PSEUDONYM_DOMAIN = "uipath-cli/telemetry/pseudonym/v1:";
-var PSEUDONYM_HEX_LENGTH = 32;
-var SHA256_K = new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var SHA256_INITIAL_STATE = new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-function rotr(value, bits) {
-  return (value >>> bits | value << 32 - bits) >>> 0;
-}
-function sha256Hex(input) {
-  const bytes = new TextEncoder().encode(input);
-  const paddedLength = bytes.length + 9 + 63 >> 6 << 6;
-  const buffer = new Uint8Array(paddedLength);
-  buffer.set(bytes);
-  buffer[bytes.length] = 128;
-  const view = new DataView(buffer.buffer);
-  const bitLength = bytes.length * 8;
-  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
-  view.setUint32(paddedLength - 4, bitLength >>> 0);
-  const state = SHA256_INITIAL_STATE.slice();
-  const schedule = new Uint32Array(64);
-  for (let offset = 0;offset < paddedLength; offset += 64) {
-    for (let i = 0;i < 16; i++) {
-      schedule[i] = view.getUint32(offset + i * 4);
+class NodeFileSystem {
+  path = {
+    join: path.join,
+    resolve: path.resolve,
+    relative: path.relative,
+    dirname: path.dirname,
+    isAbsolute: path.isAbsolute,
+    basename: path.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os.homedir,
+    tmpdir: os.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      const { default: open } = await import("./index-nzr4mx5p.js");
+      await open(url);
     }
-    for (let i = 16;i < 64; i++) {
-      const x = schedule[i - 15];
-      const y = schedule[i - 2];
-      const s0 = (rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3) >>> 0;
-      const s1 = (rotr(y, 17) ^ rotr(y, 19) ^ y >>> 10) >>> 0;
-      schedule[i] = schedule[i - 16] + s0 + schedule[i - 7] + s1 >>> 0;
+  };
+  async readFile(path2, options) {
+    try {
+      if (options) {
+        return await fs.readFile(path2, "utf-8");
+      }
+      return await fs.readFile(path2);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
     }
-    let a = state[0];
-    let b = state[1];
-    let c = state[2];
-    let d = state[3];
-    let e = state[4];
-    let f = state[5];
-    let g = state[6];
-    let h = state[7];
-    for (let i = 0;i < 64; i++) {
-      const s1 = (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) >>> 0;
-      const ch = (e & f ^ ~e & g) >>> 0;
-      const temp1 = h + s1 + ch + SHA256_K[i] + schedule[i] >>> 0;
-      const s0 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) >>> 0;
-      const maj = (a & b ^ a & c ^ b & c) >>> 0;
-      const temp2 = s0 + maj >>> 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + temp1 >>> 0;
-      d = c;
-      c = b;
-      b = a;
-      a = temp1 + temp2 >>> 0;
+  }
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
     }
-    state[0] = state[0] + a >>> 0;
-    state[1] = state[1] + b >>> 0;
-    state[2] = state[2] + c >>> 0;
-    state[3] = state[3] + d >>> 0;
-    state[4] = state[4] + e >>> 0;
-    state[5] = state[5] + f >>> 0;
-    state[6] = state[6] + g >>> 0;
-    state[7] = state[7] + h >>> 0;
+    await fs.writeFile(filePath, data);
   }
-  let hex = "";
-  for (const word of state) {
-    hex += word.toString(16).padStart(8, "0");
+  async appendFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    await fs.appendFile(filePath, data);
   }
-  return hex;
-}
-function resolveSha256Hex() {
-  try {
-    const nodeCrypto = __require("node:crypto");
-    const createHash = nodeCrypto?.createHash;
-    if (typeof createHash !== "function") {
-      return sha256Hex;
+  async readdir(dirPath) {
+    try {
+      return await fs.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
     }
-    const native = (input) => createHash("sha256").update(input, "utf8").digest("hex");
-    return native("abc") === sha256Hex("abc") ? native : sha256Hex;
-  } catch {
-    return sha256Hex;
   }
-}
-var cachedSha256Hex;
-function digest(input) {
-  cachedSha256Hex ??= resolveSha256Hex();
-  return cachedSha256Hex(input);
-}
-function pseudonymize(input) {
-  return digest(`${PSEUDONYM_DOMAIN}${input}`).slice(0, PSEUDONYM_HEX_LENGTH);
-}
-
-// ../common/src/singleton.ts
-var PREFIX = "@uipath/common/";
-var _g = globalThis;
-function singleton(ctorOrName) {
-  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
-  const key = Symbol.for(PREFIX + name);
-  return {
-    get(fallback) {
-      return _g[key] ?? fallback;
-    },
-    set(value) {
-      _g[key] = value;
-    },
-    clear() {
-      delete _g[key];
-    },
-    getOrInit(factory, guard) {
-      const existing = _g[key];
-      if (existing != null && typeof existing === "object") {
-        if (!guard || guard(existing)) {
-          return existing;
+  async readdirEntries(dirPath) {
+    try {
+      return await fs.readdir(dirPath, { withFileTypes: true });
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+        ctimeMs: stats.ctimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
         }
+        const stats = await fs.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
       }
-      const instance = factory();
-      _g[key] = instance;
-      return instance;
     }
-  };
-}
-
-// ../common/src/telemetry/supplied-values.ts
-var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
-function activeEntries() {
-  const existing = suppliedValuesSlot.get();
-  return Array.isArray(existing) ? existing : [];
-}
-var MIN_SCRUBBABLE_LENGTH = 4;
-function recordSuppliedArgumentValues(values) {
-  const flat = [];
-  const push = (value) => {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        push(item);
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path.resolve(lockPath);
+    const fullReal = await fs.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path.dirname(absolute);
+    const base = path.basename(absolute);
+    const canonicalParent = await fs.realpath(parent).catch(() => parent);
+    return path.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
       }
-      return;
-    }
-    if (typeof value === "string" && value.length >= MIN_SCRUBBABLE_LENGTH) {
-      flat.push(value);
-    }
-  };
-  push(values);
-  const entry = { values: flat };
-  suppliedValuesSlot.set([...activeEntries(), entry]);
-  return entry;
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs.rm(lockFile, { force: true });
+      }
+    };
+  }
+  async rm(filePath) {
+    await fs.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs.rename(oldPath, newPath);
+  }
+  async isSymbolicLink(filePath) {
+    try {
+      return (await fs.lstat(filePath)).isSymbolicLink();
+    } catch (error) {
+      if (this.isEnoent(error) || this.hasErrnoCode(error, "ENOTDIR")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async hashFile(filePath) {
+    let handle;
+    try {
+      handle = await fs.open(filePath, "r");
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+    const buffer = hashBuffers.pop() ?? Buffer.allocUnsafe(HASH_CHUNK_BYTES);
+    try {
+      const opened = await handle.stat();
+      const stats = {
+        isFile: () => opened.isFile(),
+        isDirectory: () => opened.isDirectory(),
+        size: opened.size,
+        mtimeMs: opened.mtimeMs,
+        ctimeMs: opened.ctimeMs
+      };
+      const hash = createHash("sha256");
+      let size = 0;
+      for (;; ) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+        if (bytesRead === 0)
+          break;
+        hash.update(buffer.subarray(0, bytesRead));
+        size += bytesRead;
+      }
+      return { sha256: hash.digest("hex"), size, stats };
+    } finally {
+      if (hashBuffers.length < HASH_BUFFERS_KEPT) {
+        hashBuffers.push(buffer);
+      }
+      await handle.close();
+    }
+  }
+  async realpath(filePath) {
+    try {
+      return await fs.realpath(filePath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return filePath;
+      throw error;
+    }
+  }
+  async getTempDir() {
+    return await fs.mkdtemp(path.join(os.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path.join(sourcePath, entry);
+      const destEntry = path.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  }
+}
+
+// ../filesystem/src/index.ts
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => fsInstance;
+
+// ../common/src/telemetry/telemetry-dimensions.ts
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ProjectDimensions = {
+  ProjectKey: "ProjectKey",
+  ProjectType: "ProjectType",
+  ProjectIdentityStatus: "ProjectIdentityStatus",
+  SolutionKey: "SolutionKey",
+  SolutionProjectKey: "SolutionProjectKey",
+  SolutionIdentityStatus: "SolutionIdentityStatus",
+  PreviousSolutionKey: "PreviousSolutionKey"
+};
+var GUID_KEY_DIMENSIONS = new Set([
+  ProjectDimensions.ProjectKey,
+  ProjectDimensions.SolutionKey,
+  ProjectDimensions.SolutionProjectKey,
+  ProjectDimensions.PreviousSolutionKey
+]);
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage",
+  HttpStatus: "HttpStatus",
+  UpstreamErrorCode: "UpstreamErrorCode"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ProjectDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ProjectDimensions)
+]);
+function lowercaseIdDimensionValues(properties) {
+  let changed = false;
+  const result = {
+    ...properties
+  };
+  for (const key of Object.keys(result)) {
+    const value = result[key];
+    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
+      continue;
+    }
+    const lowered = value.toLowerCase();
+    if (lowered !== value) {
+      result[key] = lowered;
+      changed = true;
+    }
+  }
+  return changed ? result : properties;
+}
+
+// ../common/src/telemetry/project-identity.ts
+function projectKey(id) {
+  if (typeof id !== "string")
+    return;
+  const key = id.trim().toLowerCase().replaceAll("-", "");
+  return /^[0-9a-f]{32}$/.test(key) ? key : undefined;
+}
+function projectIdentityProperties(identity) {
+  const key = identity.id ? projectKey(identity.id) : undefined;
+  return {
+    [ProjectDimensions.ProjectIdentityStatus]: identity.status === "resolved" && !key ? "invalid" : identity.status,
+    [ProjectDimensions.ProjectType]: identity.projectType,
+    ...identity.status === "resolved" && key ? {
+      [ProjectDimensions.ProjectKey]: key
+    } : {}
+  };
+}
+var PROJECT_IDENTITY_LOOKUP_BUDGET_MS = 1000;
+async function withinProjectIdentityBudget(work, onTimeout) {
+  work.catch(() => {
+    return;
+  });
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      onTimeout?.();
+      resolve(undefined);
+    }, PROJECT_IDENTITY_LOOKUP_BUDGET_MS);
+  });
+  try {
+    return await Promise.race([work, expired]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ../common/src/telemetry/pseudonymize.ts
+var PSEUDONYM_DOMAIN = "uipath-cli/telemetry/pseudonym/v1:";
+var PSEUDONYM_HEX_LENGTH = 32;
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+function rotr(value, bits) {
+  return (value >>> bits | value << 32 - bits) >>> 0;
+}
+function sha256Hex(input) {
+  const bytes = new TextEncoder().encode(input);
+  const paddedLength = bytes.length + 9 + 63 >> 6 << 6;
+  const buffer = new Uint8Array(paddedLength);
+  buffer.set(bytes);
+  buffer[bytes.length] = 128;
+  const view = new DataView(buffer.buffer);
+  const bitLength = bytes.length * 8;
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const state = SHA256_INITIAL_STATE.slice();
+  const schedule = new Uint32Array(64);
+  for (let offset = 0;offset < paddedLength; offset += 64) {
+    for (let i = 0;i < 16; i++) {
+      schedule[i] = view.getUint32(offset + i * 4);
+    }
+    for (let i = 16;i < 64; i++) {
+      const x = schedule[i - 15];
+      const y = schedule[i - 2];
+      const s0 = (rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3) >>> 0;
+      const s1 = (rotr(y, 17) ^ rotr(y, 19) ^ y >>> 10) >>> 0;
+      schedule[i] = schedule[i - 16] + s0 + schedule[i - 7] + s1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let i = 0;i < 64; i++) {
+      const s1 = (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) >>> 0;
+      const ch = (e & f ^ ~e & g) >>> 0;
+      const temp1 = h + s1 + ch + SHA256_K[i] + schedule[i] >>> 0;
+      const s0 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) >>> 0;
+      const maj = (a & b ^ a & c ^ b & c) >>> 0;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  let hex = "";
+  for (const word of state) {
+    hex += word.toString(16).padStart(8, "0");
+  }
+  return hex;
+}
+function resolveSha256Hex() {
+  try {
+    const nodeCrypto = __require("node:crypto");
+    const createHash = nodeCrypto?.createHash;
+    if (typeof createHash !== "function") {
+      return sha256Hex;
+    }
+    const native = (input) => createHash("sha256").update(input, "utf8").digest("hex");
+    return native("abc") === sha256Hex("abc") ? native : sha256Hex;
+  } catch {
+    return sha256Hex;
+  }
+}
+var cachedSha256Hex;
+function digest(input) {
+  cachedSha256Hex ??= resolveSha256Hex();
+  return cachedSha256Hex(input);
+}
+function pseudonymize(input) {
+  return digest(`${PSEUDONYM_DOMAIN}${input}`).slice(0, PSEUDONYM_HEX_LENGTH);
+}
+
+// ../common/src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// ../common/src/telemetry/supplied-values.ts
+var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
+function activeEntries() {
+  const existing = suppliedValuesSlot.get();
+  return Array.isArray(existing) ? existing : [];
+}
+var MIN_SCRUBBABLE_LENGTH = 4;
+function recordSuppliedArgumentValues(values) {
+  const flat = [];
+  const push = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        push(item);
+      }
+      return;
+    }
+    if (typeof value === "string" && value.length >= MIN_SCRUBBABLE_LENGTH) {
+      flat.push(value);
+    }
+  };
+  push(values);
+  const entry = { values: flat };
+  suppliedValuesSlot.set([...activeEntries(), entry]);
+  return entry;
 }
 function releaseSuppliedArgumentValues(entry) {
   suppliedValuesSlot.set(activeEntries().filter((held) => held !== entry));
@@ -2563,6 +3032,8 @@ function redactProperty(name, value) {
   if (isSensitiveName(name)) {
     return REDACTED;
   }
+  if (GUID_KEY_DIMENSIONS.has(name))
+    return projectKey(value);
   if (typeof value === "boolean" || typeof value === "number") {
     return value;
   }
@@ -2619,7 +3090,7 @@ function toError(error) {
 function isPromiseLike(value) {
   return value !== null && typeof value === "object" && typeof value.then === "function";
 }
-function catchError(fnOrPromise) {
+function catchError2(fnOrPromise) {
   if (isPromiseLike(fnOrPromise)) {
     return settlePromiseLike(fnOrPromise);
   }
@@ -2637,9 +3108,78 @@ function settlePromiseLike(thenable) {
   return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
 }
 
+// ../common/src/result-types.ts
+var RESULTS = {
+  Success: "Success",
+  Failure: "Failure",
+  ConfigError: "ConfigError",
+  AuthenticationError: "AuthenticationError",
+  ValidationError: "ValidationError",
+  TimeoutError: "TimeoutError"
+};
+
+// ../../node_modules/commander/index.js
+var exports_commander = {};
+__exportCjs(exports_commander, {
+  program: () => $program,
+  createCommand: () => $createCommand,
+  createOption: () => $createOption,
+  createArgument: () => $createArgument,
+  Command: () => $Command,
+  Option: () => $Option,
+  Argument: () => $Argument,
+  Help: () => $Help,
+  CommanderError: () => $CommanderError,
+  InvalidArgumentError: () => $InvalidArgumentError,
+  InvalidOptionArgumentError: () => $InvalidOptionArgumentError
+}, {
+  program: (value) => $program = value,
+  createCommand: (value) => $createCommand = value,
+  createOption: (value) => $createOption = value,
+  createArgument: (value) => $createArgument = value,
+  Command: (value) => $Command = value,
+  Option: (value) => $Option = value,
+  Argument: (value) => $Argument = value,
+  Help: (value) => $Help = value,
+  CommanderError: (value) => $CommanderError = value,
+  InvalidArgumentError: (value) => $InvalidArgumentError = value,
+  InvalidOptionArgumentError: (value) => $InvalidOptionArgumentError = value
+});
+var { Argument } = require_argument();
+var { Command } = require_command();
+var { CommanderError, InvalidArgumentError } = require_error();
+var { Help } = require_help();
+var { Option: Option2 } = require_option();
+var $program = new Command;
+var $createCommand = (name) => new Command(name);
+var $createOption = (flags, description) => new Option2(flags, description);
+var $createArgument = (name, description) => new Argument(name, description);
+var $Command = Command;
+var $Option = Option2;
+var $Argument = Argument;
+var $Help = Help;
+var $CommanderError = CommanderError;
+var $InvalidArgumentError = InvalidArgumentError;
+var $InvalidOptionArgumentError = InvalidArgumentError;
+
+// ../../node_modules/commander/esm.mjs
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError: CommanderError2,
+  InvalidArgumentError: InvalidArgumentError2,
+  InvalidOptionArgumentError,
+  Command: Command2,
+  Argument: Argument2,
+  Option,
+  Help: Help2
+} = exports_commander;
+
 // ../common/src/output-context.ts
 function createStorage() {
-  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  const [error, mod] = catchError2(() => __require("node:async_hooks"));
   if (error || typeof mod?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
@@ -2708,7 +3248,7 @@ class SimpleLogger {
       }
       return DEFAULT_LOG_LEVEL;
     }
-    const [localStorageError, hasDebug] = catchError(() => typeof localStorage !== "undefined" && !!localStorage.getItem("debug"));
+    const [localStorageError, hasDebug] = catchError2(() => typeof localStorage !== "undefined" && !!localStorage.getItem("debug"));
     if (!localStorageError && hasDebug) {
       return 0 /* DEBUG */;
     }
@@ -2804,7 +3344,7 @@ class SimpleLogger {
     this.fileLoggingEnabled = true;
     const fs = getFileSystem();
     this.pendingInit = (async () => {
-      const [error] = await catchError((async () => {
+      const [error] = await catchError2((async () => {
         await fs.mkdir(fs.path.dirname(path));
         await fs.writeFile(path, "");
       })());
@@ -2869,40 +3409,61 @@ function getOutputFilter() {
   return filterSlot.get();
 }
 
-// ../common/src/exit-code.ts
-function setExitCode(code) {
-  process.exitCode = code;
+// ../common/src/error-codes.ts
+var CLI_ERROR_CODES = [
+  "invalid_argument",
+  "authentication_required",
+  "permission_denied",
+  "local_permission_denied",
+  "not_found",
+  "rate_limited",
+  "network_error",
+  "timeout",
+  "server_error",
+  "method_not_allowed",
+  "not_supported",
+  "configuration_error",
+  "execution_failed",
+  "unknown_error"
+];
+var RETRY_HINTS = [
+  "RetryWillNotFix",
+  "RetryLater",
+  "RetryAfter1Second",
+  "RetryAfter10Seconds",
+  "RetryAfter30Seconds",
+  "RetryAfter60Seconds"
+];
+var CLI_ERROR_CODE_VALUES = new Set(CLI_ERROR_CODES);
+var RETRY_HINT_VALUES = new Set(RETRY_HINTS);
+function isCliErrorCode(value) {
+  return typeof value === "string" && CLI_ERROR_CODE_VALUES.has(value);
 }
-
-// ../common/src/local-permission-codes.ts
-var LOCAL_PERMISSION_ERROR_CODES = new Set([
-  "EACCES",
-  "EPERM",
-  "EROFS"
-]);
-
-// ../common/src/output-codecs.ts
-var yamlSlot = singleton("YamlCodec");
-var jmespathSlot = singleton("JmespathCodec");
-async function loadOutputCodecsAsync(needed) {
-  const loads = [];
-  if (needed.yaml && yamlSlot.get() === undefined) {
-    loads.push(import("./js-yaml-88tdqrtd.js").then((mod) => {
-      yamlSlot.set(mod);
-    }));
-  }
-  if (needed.filter && jmespathSlot.get() === undefined) {
-    loads.push(import("./jmespath-231m3hyn.js").then((m)=>__toESM(m.default,1)).then((mod) => {
-      jmespathSlot.set(mod);
-    }));
-  }
-  await Promise.all(loads);
+function isRetryHint(value) {
+  return typeof value === "string" && RETRY_HINT_VALUES.has(value);
 }
-function getYamlCodec() {
-  return yamlSlot.get();
+function carriedErrorCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const code = error.errorCode;
+  return isCliErrorCode(code) ? code : undefined;
 }
-function getJmespathCodec() {
-  return jmespathSlot.get();
+function carriedRetry(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const retry = error.retry;
+  return isRetryHint(retry) ? retry : undefined;
+}
+function defaultRetryForErrorCode(errorCode) {
+  switch (errorCode) {
+    case "network_error":
+    case "rate_limited":
+    case "server_error":
+    case "timeout":
+      return "RetryLater";
+    default:
+      return "RetryWillNotFix";
+  }
 }
 
 // ../common/src/error-graph.ts
@@ -2917,185 +3478,194 @@ function* walkErrorGraph(error) {
       continue;
     seen.add(current);
     const cur = current;
-    yield cur;
-    if (cur.cause !== undefined)
-      queue.push(cur.cause);
-    if (Array.isArray(cur.errors))
-      queue.push(...cur.errors);
-  }
-  return;
-}
-function parseHttpStatusFromMessage(message) {
-  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
-  if (!match)
-    return;
-  const status = Number(match[1]);
-  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
-}
-function findHttpStatusInGraph(error) {
-  for (const node of walkErrorGraph(error)) {
-    const response = node.response;
-    const explicit = typeof node.status === "number" ? node.status : response?.status;
-    if (typeof explicit === "number" && explicit >= 400 && explicit <= 599) {
-      return explicit;
-    }
-    if (typeof node.message === "string") {
-      const parsed = parseHttpStatusFromMessage(node.message);
-      if (parsed !== undefined && parsed >= 400) {
-        return parsed;
-      }
-    }
-  }
-  return;
-}
-
-// ../common/src/telemetry/telemetry-dimensions.ts
-var BaseDimensions = {
-  ApplicationName: "ApplicationName",
-  ProductVersion: "ProductVersion",
-  InstallationId: "InstallationId",
-  CloudUserId: "CloudUserId",
-  CloudTenantId: "CloudTenantId",
-  CloudOrganizationId: "CloudOrganizationId",
-  IsInternalUser: "IsInternalUser",
-  Environment: "Environment",
-  BaseUrl: "BaseUrl",
-  Region: "Region",
-  Agent: "Agent",
-  AgentVersion: "AgentVersion",
-  AgentModel: "AgentModel",
-  ToolName: "ToolName",
-  ToolVersion: "ToolVersion",
-  ExecutionContext: "ExecutionContext",
-  CiProvider: "CiProvider",
-  SessionIdSource: "SessionIdSource",
-  SessionId: "SessionId"
-};
-var CommandDimensions = {
-  IsCommand: "IsCommand",
-  IsReexec: "IsReexec",
-  CommandName: "CommandName",
-  ExitCode: "ExitCode",
-  TerminalOutcome: "TerminalOutcome",
-  ErrorClass: "ErrorClass",
-  TerminalSignal: "TerminalSignal",
-  ErrorMessage: "ErrorMessage",
-  SkillName: "SkillName",
-  ProductArea: "ProductArea",
-  Mode: "Mode"
-};
-var ShipDimensions = {
-  ShipKind: "ShipKind",
-  Target: "Target",
-  ProjectType: "ProjectType",
-  ProjectTypes: "ProjectTypes",
-  ArtifactCorrelationKey: "ArtifactCorrelationKey",
-  PackageName: "PackageName",
-  PackageVersion: "PackageVersion",
-  PackageVersionKey: "PackageVersionKey",
-  DeploymentKey: "DeploymentKey",
-  SolutionId: "SolutionId",
-  FolderKey: "FolderKey",
-  FeedId: "FeedId"
-};
-var ErrorDimensions = {
-  Result: "Result",
-  ErrorCode: "ErrorCode",
-  Retry: "Retry",
-  ErrorMessage: "ErrorMessage",
-  HttpStatus: "HttpStatus",
-  UpstreamErrorCode: "UpstreamErrorCode"
-};
-var AuthDimensions = {
-  AuthenticationMethod: "AuthenticationMethod",
-  Success: "Success",
-  Reason: "Reason"
-};
-var SkillsDimensions = {
-  SchemaVersion: "SchemaVersion",
-  AgentType: "AgentType",
-  SkillsVersion: "SkillsVersion",
-  UipSubcommand: "UipSubcommand",
-  FileExtension: "FileExtension",
-  SubagentModel: "SubagentModel",
-  SubagentType: "SubagentType",
-  PermissionMode: "PermissionMode",
-  EffortLevel: "EffortLevel",
-  SessionSource: "SessionSource",
-  Outcome: "Outcome",
-  DurationMs: "DurationMs",
-  Source: "Source"
-};
-var PackagerDimensions = {
-  ProjectId: "ProjectId",
-  ProjectType: "ProjectType",
-  SolutionId: "SolutionId"
-};
-var ScopeDimensions = {
-  FolderId: "FolderId"
-};
-var ID_DIMENSIONS = new Set([
-  BaseDimensions.CloudUserId,
-  BaseDimensions.CloudTenantId,
-  BaseDimensions.CloudOrganizationId,
-  BaseDimensions.InstallationId,
-  ShipDimensions.ArtifactCorrelationKey,
-  ShipDimensions.PackageVersionKey,
-  ShipDimensions.DeploymentKey,
-  ShipDimensions.SolutionId,
-  ShipDimensions.FolderKey,
-  ShipDimensions.FeedId,
-  PackagerDimensions.ProjectId
-]);
-var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
-var RESERVED_DIMENSION_NAMES = new Set([
-  ...Object.values(BaseDimensions),
-  ...Object.values(CommandDimensions),
-  ...Object.values(ShipDimensions),
-  ...Object.values(ErrorDimensions),
-  ...Object.values(AuthDimensions),
-  ...Object.values(SkillsDimensions),
-  ...Object.values(PackagerDimensions),
-  ...Object.values(ScopeDimensions)
-]);
-var CURATED_DIMENSIONS = new Set([
-  BaseDimensions.ApplicationName,
-  BaseDimensions.ProductVersion,
-  BaseDimensions.InstallationId,
-  BaseDimensions.CloudUserId,
-  BaseDimensions.CloudTenantId,
-  BaseDimensions.CloudOrganizationId,
-  BaseDimensions.IsInternalUser,
-  BaseDimensions.Environment,
-  BaseDimensions.BaseUrl,
-  BaseDimensions.Region,
-  BaseDimensions.Agent,
-  BaseDimensions.AgentVersion,
-  BaseDimensions.ToolVersion,
-  BaseDimensions.ExecutionContext,
-  BaseDimensions.CiProvider,
-  BaseDimensions.SessionIdSource,
-  BaseDimensions.SessionId,
-  ...Object.values(CommandDimensions),
-  ...Object.values(ShipDimensions)
-]);
-function lowercaseIdDimensionValues(properties) {
-  let changed = false;
-  const result = {
-    ...properties
-  };
-  for (const key of Object.keys(result)) {
-    const value = result[key];
-    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
-      continue;
+    yield cur;
+    if (cur.cause !== undefined)
+      queue.push(cur.cause);
+    if (Array.isArray(cur.errors))
+      queue.push(...cur.errors);
+  }
+  return;
+}
+function parseHttpStatusFromMessage(message) {
+  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
+  if (!match)
+    return;
+  const status = Number(match[1]);
+  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
+}
+function findHttpStatusInGraph(error) {
+  for (const node of walkErrorGraph(error)) {
+    const response = node.response;
+    const explicit = typeof node.status === "number" ? node.status : response?.status;
+    if (typeof explicit === "number" && explicit >= 400 && explicit <= 599) {
+      return explicit;
     }
-    const lowered = value.toLowerCase();
-    if (lowered !== value) {
-      result[key] = lowered;
-      changed = true;
+    if (typeof node.message === "string") {
+      const parsed = parseHttpStatusFromMessage(node.message);
+      if (parsed !== undefined && parsed >= 400) {
+        return parsed;
+      }
     }
   }
-  return changed ? result : properties;
+  return;
+}
+
+// ../common/src/timings.ts
+var TIMINGS_ENV_VAR = "UIP_TIMINGS";
+function createStorage2() {
+  const [error, mod] = catchError2(() => __require("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
+    return {
+      getStore: () => {
+        return;
+      },
+      run: (_store, fn) => fn()
+    };
+  }
+  return new mod.AsyncLocalStorage;
+}
+var storageSlot = singleton("TimingStorage");
+var stateSlot = singleton("Timings");
+var rootStartedSlot = singleton("TimingsRootStarted");
+var longLivedHostSlot = singleton("TimingsLongLivedHost");
+var storage = storageSlot.getOrInit(createStorage2, (value) => ("getStore" in value));
+function newState(baseline) {
+  return { baseline, httpMs: 0, httpCalls: 0 };
+}
+function getState() {
+  const scoped = storage.getStore();
+  if (scoped) {
+    return scoped;
+  }
+  const pinned = livePinnedState();
+  if (pinned !== undefined) {
+    return pinned;
+  }
+  return newState(processStartIsInvocationStart() ? 0 : performance.now());
+}
+function livePinnedState() {
+  const pinned = stateSlot.get();
+  return pinned !== undefined && "httpCalls" in pinned && !pinned.finished ? pinned : undefined;
+}
+function processStartIsInvocationStart() {
+  return !rootStartedSlot.get(false) && !longLivedHostSlot.get(false);
+}
+function timingsEnabled() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const value = process.env?.[TIMINGS_ENV_VAR];
+  if (value === undefined) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+function recordExitCode(exitCode) {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().exitCode = exitCode;
+}
+function invocationStartedAt() {
+  return new Date(performance.timeOrigin + getState().baseline);
+}
+function invocationElapsedMs() {
+  return performance.now() - getState().baseline;
+}
+function markCommandStart() {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().commandStart = performance.now();
+}
+function recordCommandDuration(durationMs) {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().commandMs = durationMs;
+}
+
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
+  recordExitCode(code);
+}
+var GENERIC_FAILURE_EXIT_CODE = 1;
+function recordCommandExit(code) {
+  if (code === GENERIC_FAILURE_EXIT_CODE && getExitCode() !== 0) {
+    return;
+  }
+  setExitCode(code);
+}
+function getExitCode() {
+  const code = process.exitCode;
+  return typeof code === "number" ? code : 0;
+}
+
+// ../common/src/http-status.ts
+function classifyHttpStatus(status) {
+  if (status === undefined)
+    return;
+  if (status === 400 || status === 409 || status === 413 || status === 422) {
+    return { errorCode: "invalid_argument", retry: "RetryWillNotFix" };
+  }
+  if (status === 401) {
+    return {
+      errorCode: "authentication_required",
+      retry: "RetryWillNotFix"
+    };
+  }
+  if (status === 403) {
+    return { errorCode: "permission_denied", retry: "RetryWillNotFix" };
+  }
+  if (status === 404) {
+    return { errorCode: "not_found", retry: "RetryWillNotFix" };
+  }
+  if (status === 405) {
+    return { errorCode: "method_not_allowed", retry: "RetryWillNotFix" };
+  }
+  if (status === 408) {
+    return { errorCode: "timeout", retry: "RetryLater" };
+  }
+  if (status === 429) {
+    return { errorCode: "rate_limited", retry: "RetryLater" };
+  }
+  if (status >= 500 && status < 600) {
+    return { errorCode: "server_error", retry: "RetryLater" };
+  }
+  return;
+}
+
+// ../common/src/local-permission-codes.ts
+var LOCAL_PERMISSION_ERROR_CODES = new Set([
+  "EACCES",
+  "EPERM",
+  "EROFS"
+]);
+
+// ../common/src/output-codecs.ts
+var yamlSlot = singleton("YamlCodec");
+var jmespathSlot = singleton("JmespathCodec");
+async function loadOutputCodecsAsync(needed) {
+  const loads = [];
+  if (needed.yaml && yamlSlot.get() === undefined) {
+    loads.push(import("./js-yaml-a2bk27p6.js").then((mod) => {
+      yamlSlot.set(mod);
+    }));
+  }
+  if (needed.filter && jmespathSlot.get() === undefined) {
+    loads.push(import("./jmespath-ab6tdc42.js").then((m)=>__toESM(m.default,1)).then((mod) => {
+      jmespathSlot.set(mod);
+    }));
+  }
+  await Promise.all(loads);
+}
+function getYamlCodec() {
+  return yamlSlot.get();
+}
+function getJmespathCodec() {
+  return jmespathSlot.get();
 }
 
 // ../common/src/telemetry/command-terminal.ts
@@ -3216,17 +3786,8 @@ function terminalSignalFor(input, outcome) {
   }
   return outcome === "cancelled" ? "SIGINT" : undefined;
 }
-function classifyHttpStatus(status) {
-  if (status === 401 || status === 403) {
-    return "auth";
-  }
-  if (status === 400 || status === 409 || status === 422) {
-    return "validation";
-  }
-  if (status === 408) {
-    return "timeout";
-  }
-  return "network_http";
+function classifyFailingHttpStatus(status) {
+  return classifyFromErrorCode(classifyHttpStatus(status)?.errorCode) ?? "network_http";
 }
 function classifyFromResult(result) {
   switch (result) {
@@ -3306,7 +3867,7 @@ function classifyError(input) {
   }
   const status = recorded?.context?.httpStatus ?? findHttpStatusInGraph(input.error);
   if (status !== undefined) {
-    return classifyHttpStatus(status);
+    return classifyFailingHttpStatus(status);
   }
   return classifyFromResult(recorded?.result) ?? classifyFromErrorCode(recorded?.errorCode) ?? classifyFromError(input.error) ?? "unknown";
 }
@@ -3338,6 +3899,7 @@ function buildCommandTerminalTelemetryProperties(input) {
 var CommonTelemetryEvents = {
   Start: "Application.Start",
   Error: "Application.Error",
+  ProjectActivity: "Cli.ProjectActivity",
   ShipSucceeded: "Cli.ShipSucceeded"
 };
 
@@ -3347,7 +3909,7 @@ function readRegistryValue(keyPath, valueName) {
   if (process.platform !== "win32") {
     return "";
   }
-  const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
+  const [error, output] = catchError2(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true
@@ -3834,101 +4396,26 @@ class TelemetryService {
     const globalProperties = getGlobalTelemetryProperties();
     const enriched = {
       ...getExecutionContextTelemetryProperties(),
-      ...globalProperties,
-      ...this.defaultProperties,
-      ...redactProperties(properties ?? {}),
-      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
-      [BaseDimensions.SessionId]: this.telemetryProvider.getSessionId?.() ?? getTelemetrySessionId()
-    };
-    return lowercaseIdDimensionValues(enriched);
-  }
-  generateId() {
-    const bytes = new Uint8Array(8);
-    let hex = "";
-    do {
-      crypto.getRandomValues(bytes);
-      hex = "";
-      for (const byte of bytes) {
-        hex += byte.toString(16).padStart(2, "0");
-      }
-    } while (/^0+$/.test(hex));
-    return hex;
-  }
-}
-// ../common/src/timings.ts
-var TIMINGS_ENV_VAR = "UIP_TIMINGS";
-function createStorage2() {
-  const [error, mod] = catchError(() => __require("node:async_hooks"));
-  if (error || typeof mod?.AsyncLocalStorage !== "function") {
-    return {
-      getStore: () => {
-        return;
-      },
-      run: (_store, fn) => fn()
-    };
-  }
-  return new mod.AsyncLocalStorage;
-}
-var storageSlot = singleton("TimingStorage");
-var stateSlot = singleton("Timings");
-var rootStartedSlot = singleton("TimingsRootStarted");
-var longLivedHostSlot = singleton("TimingsLongLivedHost");
-var storage = storageSlot.getOrInit(createStorage2, (value) => ("getStore" in value));
-function newState(baseline) {
-  return { baseline, httpMs: 0, httpCalls: 0 };
-}
-function getState() {
-  const scoped = storage.getStore();
-  if (scoped) {
-    return scoped;
-  }
-  const pinned = livePinnedState();
-  if (pinned !== undefined) {
-    return pinned;
-  }
-  return newState(processStartIsInvocationStart() ? 0 : performance.now());
-}
-function livePinnedState() {
-  const pinned = stateSlot.get();
-  return pinned !== undefined && "httpCalls" in pinned && !pinned.finished ? pinned : undefined;
-}
-function processStartIsInvocationStart() {
-  return !rootStartedSlot.get(false) && !longLivedHostSlot.get(false);
-}
-function timingsEnabled() {
-  if (typeof process === "undefined") {
-    return false;
-  }
-  const value = process.env?.[TIMINGS_ENV_VAR];
-  if (value === undefined) {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true";
-}
-function recordExitCode(exitCode) {
-  if (!timingsEnabled()) {
-    return;
-  }
-  getState().exitCode = exitCode;
-}
-function invocationStartedAt() {
-  return new Date(performance.timeOrigin + getState().baseline);
-}
-function invocationElapsedMs() {
-  return performance.now() - getState().baseline;
-}
-function markCommandStart() {
-  if (!timingsEnabled()) {
-    return;
+      ...globalProperties,
+      ...this.defaultProperties,
+      ...redactProperties(properties ?? {}),
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
+      [BaseDimensions.SessionId]: this.telemetryProvider.getSessionId?.() ?? getTelemetrySessionId()
+    };
+    return lowercaseIdDimensionValues(enriched);
   }
-  getState().commandStart = performance.now();
-}
-function recordCommandDuration(durationMs) {
-  if (!timingsEnabled()) {
-    return;
+  generateId() {
+    const bytes = new Uint8Array(8);
+    let hex = "";
+    do {
+      crypto.getRandomValues(bytes);
+      hex = "";
+      for (const byte of bytes) {
+        hex += byte.toString(16).padStart(2, "0");
+      }
+    } while (/^0+$/.test(hex));
+    return hex;
   }
-  getState().commandMs = durationMs;
 }
 // ../common/src/telemetry/proxy-http-agent.ts
 var slot = singleton("ProxyAuthHttpsAgent");
@@ -3936,6 +4423,15 @@ var slot = singleton("ProxyAuthHttpsAgent");
 // ../common/src/telemetry/node-appinsights-telemetry-provider.ts
 var providerSlot = singleton("TelemetryProvider");
 
+// ../common/src/telemetry/telemetry-config.ts
+function isTelemetryDisabled() {
+  const value = process.env.UIPATH_TELEMETRY_DISABLED;
+  return value === "1" || value === "true";
+}
+function isProjectTelemetryDisabled() {
+  return isTelemetryDisabled() || process.env.UIPATH_PROJECT_TELEMETRY_DISABLED === "1" || process.env.UIPATH_PROJECT_TELEMETRY_DISABLED === "true";
+}
+
 // ../common/src/telemetry/telemetry-spool.ts
 var sidecarEntrySlot = singleton("TelemetrySidecarEntry");
 var MAX_SPOOL_AGE_MS = 72 * 60 * 60 * 1000;
@@ -3971,7 +4467,6 @@ var telemetry = new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
-
 // ../common/src/formatter.ts
 var ANSI_STYLES = {
   red: "\x1B[31m",
@@ -3981,46 +4476,6 @@ var ANSI_RESET = "\x1B[0m";
 function styleLine(line, style) {
   return style ? `${ANSI_STYLES[style]}${line}${ANSI_RESET}` : line;
 }
-var CLI_ERROR_CODES = [
-  "invalid_argument",
-  "authentication_required",
-  "permission_denied",
-  "local_permission_denied",
-  "not_found",
-  "rate_limited",
-  "network_error",
-  "timeout",
-  "server_error",
-  "method_not_allowed",
-  "not_supported",
-  "configuration_error",
-  "execution_failed",
-  "unknown_error"
-];
-var RETRY_HINTS = [
-  "RetryWillNotFix",
-  "RetryLater",
-  "RetryAfter1Second",
-  "RetryAfter10Seconds",
-  "RetryAfter30Seconds",
-  "RetryAfter60Seconds"
-];
-var CLI_ERROR_CODE_VALUES = new Set(CLI_ERROR_CODES);
-var RETRY_HINT_VALUES = new Set(RETRY_HINTS);
-function isCliErrorCode(value) {
-  return typeof value === "string" && CLI_ERROR_CODE_VALUES.has(value);
-}
-function isRetryHint(value) {
-  return typeof value === "string" && RETRY_HINT_VALUES.has(value);
-}
-var RESULTS = {
-  Success: "Success",
-  Failure: "Failure",
-  ConfigError: "ConfigError",
-  AuthenticationError: "AuthenticationError",
-  ValidationError: "ValidationError",
-  TimeoutError: "TimeoutError"
-};
 var EXIT_CODES = {
   Success: 0,
   Failure: 1,
@@ -4029,6 +4484,9 @@ var EXIT_CODES = {
   ValidationError: 3,
   TimeoutError: 4
 };
+function exitCodeForResult(result) {
+  return EXIT_CODES[result] ?? EXIT_CODES.Failure;
+}
 function escapeNonAscii(jsonText) {
   return jsonText.replace(/[\u0080-\uffff]/g, (c) => {
     const hex = c.charCodeAt(0).toString(16).padStart(4, "0");
@@ -4620,7 +5078,7 @@ function availableFields(data) {
   return [...keys];
 }
 function decodeQuotedIdentifier(whole, inner) {
-  const [error, decoded] = catchError(() => JSON.parse(whole));
+  const [error, decoded] = catchError2(() => JSON.parse(whole));
   if (!error && typeof decoded === "string")
     return decoded;
   return inner.replace(/\\(.)/g, "$1");
@@ -4704,8 +5162,8 @@ function carriesOnlyNulls(value) {
   }
   return false;
 }
-function nameList(names, cap2 = 12) {
-  const shown = names.slice(0, cap2).map((n) => `\`${n}\``);
+function nameList(names, cap = 12) {
+  const shown = names.slice(0, cap).map((n) => `\`${n}\``);
   const rest = names.length - shown.length;
   return shown.join(", ") + (rest > 0 ? `, and ${rest} more` : "");
 }
@@ -4816,7 +5274,7 @@ function filterFailureData(envelope) {
   if (!filter || data == null)
     return;
   let note;
-  const [filterError, filtered] = catchError(() => applyFilter(data, filter, (n) => {
+  const [filterError, filtered] = catchError2(() => applyFilter(data, filter, (n) => {
     note = n;
   }));
   if (filterError) {
@@ -4842,40 +5300,11 @@ function defaultErrorCodeForResult(result) {
       return "unknown_error";
   }
 }
-function parseHttpStatusFromMessage2(message) {
-  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
-  if (!match)
-    return;
-  const status = Number(match[1]);
-  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
-}
-function defaultErrorCodeForHttpStatus(status) {
-  if (status === undefined)
-    return;
-  if (status === 400 || status === 409 || status === 422) {
-    return "invalid_argument";
-  }
-  if (status === 401)
-    return "authentication_required";
-  if (status === 403)
-    return "permission_denied";
-  if (status === 404)
-    return "not_found";
-  if (status === 405)
-    return "method_not_allowed";
-  if (status === 408)
-    return "timeout";
-  if (status === 429)
-    return "rate_limited";
-  if (status >= 500 && status < 600)
-    return "server_error";
-  return;
-}
 var LOCAL_PERMISSION_TEXT_PATTERN = new RegExp(`(?:\\b|\\()(?:${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})(?::\\s|\\))`);
 function defaultErrorCodeForFailure(data) {
   if (data.Result === RESULTS.Failure) {
-    const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage2(data.Message);
-    const errorCode = defaultErrorCodeForHttpStatus(status);
+    const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage(data.Message);
+    const errorCode = classifyHttpStatus(status)?.errorCode;
     if (errorCode)
       return errorCode;
     if (status === undefined && (LOCAL_PERMISSION_TEXT_PATTERN.test(data.Message) || LOCAL_PERMISSION_TEXT_PATTERN.test(data.Instructions))) {
@@ -4884,17 +5313,6 @@ function defaultErrorCodeForFailure(data) {
   }
   return defaultErrorCodeForResult(data.Result);
 }
-function defaultRetryForErrorCode(errorCode) {
-  switch (errorCode) {
-    case "network_error":
-    case "rate_limited":
-    case "server_error":
-    case "timeout":
-      return "RetryLater";
-    default:
-      return "RetryWillNotFix";
-  }
-}
 var OutputFormatter;
 ((OutputFormatter) => {
   function success(data, options) {
@@ -4926,7 +5344,7 @@ var OutputFormatter;
     data.Log ??= getLogFilePath() || undefined;
     data.ErrorCode ??= defaultErrorCodeForFailure(data);
     data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
-    const exitCode = EXIT_CODES[data.Result] ?? 1;
+    const exitCode = exitCodeForResult(data.Result);
     setExitCode(exitCode);
     recordCommandFailureTelemetry({
       result: data.Result,
@@ -5022,6 +5440,13 @@ var OutputFormatter;
 })(OutputFormatter ||= {});
 
 // ../common/src/error-handler.ts
+var DEFAULT_401 = "Unauthorized (401). The session is missing or expired, or its token carries no scope for this API. Run `uip login status --detailed` to see the session and its scopes.";
+var DEFAULT_403 = "Forbidden (403). The account lacks permission for this operation, or the token carries no scope for this API. Run `uip login status --detailed` to see the token's scopes.";
+var DEFAULT_405 = "Method Not Allowed (405). The endpoint may not exist or the base URL may be incorrect.";
+var DEFAULT_413 = "Payload too large (413). The upload exceeded the server or CDN size limit. Reduce the package size — for example, exclude unused dependencies or remove large files from the project — and try again.";
+var CLOUDFLARE_BLOCK_403 = "Forbidden (403) by Cloudflare, in front of the service: the answer is a Cloudflare HTML page, not the service's JSON, so the service did not see the request and did not check the account's roles or the token's scopes. Cloudflare blocks a request when its content matches a firewall rule (text that looks like SQL or script code, for example) or when it comes from a network the firewall does not allow.";
+var CLOUDFLARE_BLOCK_403_INSTRUCTIONS = "If the request carries text that looks like code, change that text and try again. Otherwise send the time of the request and the Cloudflare Ray ID, when the message gives one, to the owner of the service or UiPath support.";
+var HTML_RESPONSE_MESSAGE = "Received HTML instead of the expected JSON response.";
 var NETWORK_ERROR_CODES = new Set([
   "ECONNREFUSED",
   "ECONNRESET",
@@ -5046,29 +5471,544 @@ var TLS_ERROR_CODES2 = new Set([
 var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
 var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
 var LOCAL_PERMISSION_MESSAGE_PATTERN = new RegExp(`\\b(${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})\\b`);
+function localPermissionInstructions(code, path) {
+  const target = path !== undefined ? `'${path}'` : "a local file or resource";
+  if (code === "EROFS") {
+    return `The filesystem containing ${target} is read-only (EROFS), so the ` + "CLI could not write to it. This is a local environment problem, " + "not a UiPath service error — retrying will not help. Use a " + "writable location, or give this environment write access to the " + "path.";
+  }
+  const onWindows = typeof process !== "undefined" && process.platform === "win32";
+  const remedy = onWindows ? "Re-run from an elevated terminal, close any program holding " + "the file open, or grant your user access to the path." : "Grant this user (or the sandbox the command runs in) access " + "to the path, or run the command outside the sandbox.";
+  return `The operating system denied access to ${target} (${code}). This is ` + "a local permission problem, not a UiPath service error — retrying " + `without a permission change will not help. ${remedy}`;
+}
+function describeConnectivityError(error) {
+  for (const cur of walkErrorGraph(error)) {
+    const code = typeof cur.code === "string" ? cur.code : undefined;
+    const message = typeof cur.message === "string" ? cur.message : undefined;
+    if (code && TLS_ERROR_CODES2.has(code)) {
+      return {
+        code,
+        kind: "tls",
+        message: message ?? code,
+        instructions: TLS_INSTRUCTIONS
+      };
+    }
+    if (code && NETWORK_ERROR_CODES.has(code)) {
+      return {
+        code,
+        kind: "network",
+        message: message ?? code,
+        instructions: NETWORK_INSTRUCTIONS
+      };
+    }
+  }
+  return;
+}
+function describePermissionError(error) {
+  for (const cur of walkErrorGraph(error)) {
+    const message = typeof cur.message === "string" ? cur.message : undefined;
+    const code = matchLocalPermissionCode(cur.code, message);
+    if (!code)
+      continue;
+    const path = localPermissionPath(cur.path, message);
+    return {
+      code,
+      message: message ?? code,
+      ...path !== undefined ? { path } : {},
+      instructions: localPermissionInstructions(code, path)
+    };
+  }
+  return;
+}
+function matchLocalPermissionCode(code, message) {
+  if (typeof code === "string" && LOCAL_PERMISSION_ERROR_CODES.has(code)) {
+    return code;
+  }
+  const match = message ? LOCAL_PERMISSION_MESSAGE_PATTERN.exec(message) : null;
+  return match ? match[1] : undefined;
+}
+function localPermissionPath(path, message) {
+  if (typeof path === "string")
+    return path;
+  return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
+}
+function readHeader(response, name) {
+  const headers = response?.headers;
+  if (!headers || typeof headers !== "object")
+    return;
+  if (typeof headers.get === "function") {
+    const value = headers.get(name);
+    if (value)
+      return value;
+  }
+  const plain = headers;
+  const key = Object.keys(plain).find((k) => k.toLowerCase() === name.toLowerCase());
+  const value = key === undefined ? undefined : plain[key];
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+function isHtmlDocument(body) {
+  return /^\s*(<!doctype html|<html\b)/i.test(body);
+}
+function retryHintForRetryAfter(seconds) {
+  if (seconds <= 1) {
+    return "RetryAfter1Second";
+  }
+  if (seconds <= 10) {
+    return "RetryAfter10Seconds";
+  }
+  if (seconds <= 30) {
+    return "RetryAfter30Seconds";
+  }
+  return "RetryAfter60Seconds";
+}
+function classifyError2(status, error) {
+  const byStatus = classifyHttpStatus(status);
+  if (byStatus)
+    return byStatus;
+  if (status === undefined && describePermissionError(error)) {
+    return {
+      errorCode: "local_permission_denied",
+      retry: "RetryWillNotFix"
+    };
+  }
+  const connectivity = describeConnectivityError(error);
+  if (connectivity) {
+    return {
+      errorCode: "network_error",
+      retry: connectivity.kind === "tls" ? "RetryWillNotFix" : "RetryLater"
+    };
+  }
+  return { errorCode: "unknown_error", retry: "RetryWillNotFix" };
+}
+function withCarriedClass(inferred, error) {
+  const errorCode = carriedErrorCode(error);
+  const retry = carriedRetry(error);
+  if (errorCode === undefined || errorCode === inferred.errorCode) {
+    return {
+      errorCode: inferred.errorCode,
+      retry: retry ?? inferred.retry
+    };
+  }
+  return { errorCode, retry: retry ?? defaultRetryForErrorCode(errorCode) };
+}
+function formatHttpStatusMessage(status, rawMessage, extractedMessage, inferredStatus) {
+  if (extractedMessage) {
+    return `HTTP ${status}: ${extractedMessage}`;
+  }
+  return inferredStatus !== undefined ? rawMessage : `HTTP ${status}: ${rawMessage}`;
+}
+async function extractErrorDetails(error, options) {
+  const err = error !== null && error !== undefined && typeof error === "object" ? error : {};
+  const response = err.response;
+  const rawMessage = typeof err.message === "string" ? err.message : "Unknown error";
+  const explicitStatus = err.status ?? response?.status;
+  const inferredStatus = explicitStatus === undefined ? parseHttpStatusFromMessage(rawMessage) : undefined;
+  const status = explicitStatus ?? inferredStatus;
+  const isSuccessfulResponse = status !== undefined && status >= 200 && status < 300;
+  let rawBody;
+  let extractedMessage;
+  let parsedBody;
+  const textFn = response?.text?.bind(response);
+  if (textFn) {
+    const [bodyError, body] = await catchError2((async () => textFn())());
+    if (!bodyError && body) {
+      rawBody = body;
+      const [parseError, parsed] = catchError2(() => JSON.parse(body));
+      if (!parseError && parsed && typeof parsed === "object") {
+        parsedBody = parsed;
+        if (parsedBody.errors && typeof parsedBody.errors === "object") {
+          for (const field of Object.values(parsedBody.errors)) {
+            if (Array.isArray(field) && field.length > 0) {
+              const first = field[0];
+              if (first && typeof first.message === "string") {
+                extractedMessage = first.message;
+                break;
+              }
+            }
+          }
+        }
+        if (!extractedMessage) {
+          extractedMessage = typeof parsedBody.message === "string" ? parsedBody.message : typeof parsedBody.errorMessage === "string" ? parsedBody.errorMessage : typeof parsedBody.title === "string" ? parsedBody.title : undefined;
+        }
+        if (!extractedMessage) {
+          extractedMessage = body;
+        }
+        if (extractedMessage && typeof parsedBody.detail === "string" && parsedBody.detail.length > 0 && !extractedMessage.includes(parsedBody.detail)) {
+          extractedMessage = `${extractedMessage}: ${parsedBody.detail}`;
+        }
+      } else {
+        extractedMessage = isHtmlDocument(body) ? HTML_RESPONSE_MESSAGE : body;
+      }
+    }
+  }
+  let message;
+  let result = "Failure";
+  const classificationStatus = status ?? findHttpStatusInGraph(error);
+  const classification = classifyError2(classificationStatus, error);
+  let retry = classification.retry;
+  const htmlForbidden = status === 403 && rawBody !== undefined && isHtmlDocument(rawBody);
+  const rayId = htmlForbidden ? readHeader(response, "cf-ray") : undefined;
+  const cloudflareBlock = htmlForbidden && (rayId !== undefined || /\bcloudflare\b/i.test(readHeader(response, "server") ?? ""));
+  if (status === 401) {
+    message = DEFAULT_401;
+    result = "AuthenticationError";
+  } else if (cloudflareBlock) {
+    message = rayId ? `${CLOUDFLARE_BLOCK_403} Cloudflare Ray ID: ${rayId}.` : CLOUDFLARE_BLOCK_403;
+  } else if (status === 403) {
+    message = options?.forbiddenMessage ?? DEFAULT_403;
+    result = "AuthenticationError";
+  } else if (status === 405) {
+    message = DEFAULT_405;
+  } else if (status === 413) {
+    message = DEFAULT_413;
+  } else if (status === 400 || status === 422) {
+    message = formatHttpStatusMessage(status, rawMessage, extractedMessage, inferredStatus);
+    result = "ValidationError";
+  } else if (status === 429) {
+    message = formatHttpStatusMessage(status, rawMessage, extractedMessage, inferredStatus);
+  } else if (extractedMessage) {
+    if (isSuccessfulResponse && rawMessage !== "Unknown error") {
+      message = rawMessage;
+    } else {
+      message = status ? `HTTP ${status}: ${extractedMessage}` : extractedMessage;
+    }
+  } else if (status) {
+    if (inferredStatus !== undefined) {
+      message = rawMessage;
+    } else if (rawMessage === "Unknown error" && response) {
+      const statusText = response.statusText;
+      message = statusText ? `HTTP ${status} ${statusText}` : `HTTP ${status} - request failed`;
+    } else {
+      message = `HTTP ${status}: ${rawMessage}`;
+    }
+  } else {
+    message = rawMessage;
+  }
+  if (status === undefined) {
+    const connectivity = describeConnectivityError(error);
+    if (connectivity && connectivity.message !== message && !message.includes(connectivity.message)) {
+      message = `${message}: ${connectivity.message}`;
+    }
+  }
+  const permission = status === undefined ? describePermissionError(error) : undefined;
+  if (permission) {
+    if (permission.message !== message && !message.includes(permission.message)) {
+      message = `${message}: ${permission.message}`;
+    }
+    if (!message.includes(permission.instructions)) {
+      const punctuated = message.endsWith(".") ? message : `${message}.`;
+      message = `${punctuated} ${permission.instructions}`;
+    }
+  }
+  let details = rawMessage;
+  if (htmlForbidden) {
+    details = cloudflareBlock ? CLOUDFLARE_BLOCK_403_INSTRUCTIONS : HTML_RESPONSE_MESSAGE;
+  } else if (rawBody) {
+    if (parsedBody) {
+      const extra = {};
+      if (parsedBody.errorCode)
+        extra.errorCode = parsedBody.errorCode;
+      if (parsedBody.detail)
+        extra.detail = parsedBody.detail;
+      if (parsedBody.details)
+        extra.details = parsedBody.details;
+      if (parsedBody.errors != null)
+        extra.errors = parsedBody.errors;
+      if (parsedBody.data && typeof parsedBody.data === "object" && Object.keys(parsedBody.data).length > 0) {
+        extra.data = parsedBody.data;
+      }
+      details = Object.keys(extra).length > 0 ? JSON.stringify(extra) : rawBody;
+    } else {
+      details = rawBody;
+    }
+  } else if (typeof err.message === "string") {
+    details = err.message;
+  } else {
+    details = describeThrownValue(error);
+  }
+  const context = {};
+  if (classificationStatus) {
+    context.httpStatus = classificationStatus;
+  }
+  if (parsedBody?.errorCode && typeof parsedBody.errorCode === "string") {
+    context.errorCode = parsedBody.errorCode;
+  } else if (parsedBody?.code && typeof parsedBody.code === "string") {
+    context.errorCode = parsedBody.code;
+  }
+  if (parsedBody?.requestId && typeof parsedBody.requestId === "string") {
+    context.requestId = parsedBody.requestId;
+  } else if (cloudflareBlock && rayId) {
+    context.requestId = rayId;
+  }
+  if (parsedBody?.traceId && typeof parsedBody.traceId === "string") {
+    context.traceId = parsedBody.traceId;
+  }
+  if (permission?.path !== undefined) {
+    context.path = permission.path;
+  }
+  if (status === 429) {
+    const retryAfterValue = readHeader(response, "retry-after");
+    if (retryAfterValue) {
+      const seconds = Number(retryAfterValue);
+      if (!Number.isNaN(seconds)) {
+        context.retryAfter = seconds;
+        retry = retryHintForRetryAfter(seconds);
+      }
+    }
+  }
+  const hasContext = Object.keys(context).length > 0;
+  let parsedErrors;
+  if (parsedBody?.errors && typeof parsedBody.errors === "object") {
+    const errors = {};
+    for (const [field, raw] of Object.entries(parsedBody.errors)) {
+      if (Array.isArray(raw)) {
+        const messages = raw.map((entry) => {
+          if (typeof entry === "string")
+            return entry;
+          if (entry && typeof entry === "object" && typeof entry.message === "string") {
+            return entry.message;
+          }
+          return String(entry);
+        }).filter(Boolean);
+        if (messages.length > 0)
+          errors[field] = messages;
+      } else if (typeof raw === "string") {
+        errors[field] = [raw];
+      }
+    }
+    if (Object.keys(errors).length > 0)
+      parsedErrors = errors;
+  }
+  return {
+    result,
+    ...withCarriedClass({ errorCode: classification.errorCode, retry }, error),
+    message,
+    details,
+    ...hasContext ? { context } : {},
+    ...parsedErrors ? { parsedErrors } : {}
+  };
+}
 
-// ../common/src/classified-failure.ts
-var MAX_QUOTED_BODY_CHARS = 200;
-function summarizePlatformBody(body) {
-  const trimmed = body.trim().replace(/\s+/g, " ");
-  return trimmed.length > MAX_QUOTED_BODY_CHARS ? `${trimmed.slice(0, MAX_QUOTED_BODY_CHARS)}…` : trimmed;
+// ../common/src/pass-through-tail.ts
+function maybeOption(arg) {
+  return arg.length > 1 && arg[0] === "-";
+}
+function tokenizeTail(cmd, tail) {
+  const find = (flag) => cmd.options.find((option) => option.long === flag || option.short === flag);
+  const digitShort = cmd.options.some((option) => option.short !== undefined && /^-\d$/.test(option.short));
+  const negativeNumber = (arg) => !digitShort && /^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg);
+  const tokens = [];
+  let firstUnknown = -1;
+  let sentinel = -1;
+  let variadic;
+  let group;
+  let groupIndex = 0;
+  let i = 0;
+  while (i < tail.length || group !== undefined) {
+    const index = group === undefined ? i : groupIndex;
+    const arg = group ?? tail[i++];
+    group = undefined;
+    if (arg === "--") {
+      sentinel = index;
+      tokens.push({ kind: "sentinel", index });
+      for (let j = i;j < tail.length; j++) {
+        tokens.push({
+          kind: "operand",
+          index: j,
+          text: tail[j],
+          literal: true
+        });
+      }
+      break;
+    }
+    if (variadic && (!maybeOption(arg) || negativeNumber(arg))) {
+      tokens.push({
+        kind: "option",
+        index,
+        text: arg,
+        option: variadic,
+        value: arg
+      });
+      continue;
+    }
+    variadic = undefined;
+    if (maybeOption(arg)) {
+      const option = find(arg);
+      if (option) {
+        let value;
+        if (option.required) {
+          value = tail[i];
+          if (value !== undefined)
+            i++;
+        } else if (option.optional) {
+          const next = tail[i];
+          if (next !== undefined && (!maybeOption(next) || negativeNumber(next))) {
+            value = next;
+            i++;
+          }
+        }
+        tokens.push({
+          kind: "option",
+          index,
+          text: arg,
+          option,
+          ...value === undefined ? {} : { value }
+        });
+        variadic = option.variadic ? option : undefined;
+        continue;
+      }
+    }
+    if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
+      const option = find(`-${arg[1]}`);
+      if (option) {
+        if (option.required || option.optional) {
+          tokens.push({
+            kind: "option",
+            index,
+            text: arg,
+            option,
+            value: arg.slice(2)
+          });
+        } else {
+          tokens.push({ kind: "option", index, text: arg, option });
+          group = `-${arg.slice(2)}`;
+          groupIndex = index;
+        }
+        continue;
+      }
+    }
+    if (/^--[^=]+=/.test(arg)) {
+      const equals = arg.indexOf("=");
+      const option = find(arg.slice(0, equals));
+      if (option && (option.required || option.optional)) {
+        tokens.push({
+          kind: "option",
+          index,
+          text: arg,
+          option,
+          value: arg.slice(equals + 1)
+        });
+        continue;
+      }
+    }
+    if (maybeOption(arg) && !negativeNumber(arg)) {
+      const equals = arg.startsWith("--") ? arg.indexOf("=") : -1;
+      if (firstUnknown === -1)
+        firstUnknown = index;
+      tokens.push({
+        kind: "unknown",
+        index,
+        text: arg,
+        flag: equals > 0 ? arg.slice(0, equals) : arg,
+        ...equals > 0 ? { inlineValue: arg.slice(equals + 1) } : {}
+      });
+      continue;
+    }
+    tokens.push({ kind: "operand", index, text: arg, literal: false });
+  }
+  return { tokens, firstUnknown, sentinel };
 }
 
-// ../../node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
+// ../common/src/project-telemetry.ts
+var RESOLVER = Symbol.for("@uipath/common/projectTelemetryResolver");
+var CAPTURE = Symbol.for("@uipath/common/projectTelemetryCapture");
+var CONTEXT_RESOLVER = Symbol.for("@uipath/common/projectContextTelemetryResolver");
+var RULES = Symbol.for("@uipath/common/projectTargetRules");
+function logSkipped(what, error) {
+  logger.debug(`[project-telemetry] ${what} skipped: ${error instanceof Error ? error.message : String(error)}`);
+}
+function bounded(work, what) {
+  return withinProjectIdentityBudget(work, () => logSkipped(what, `no answer within ${PROJECT_IDENTITY_LOOKUP_BUDGET_MS} ms`));
+}
+async function identityWithContext(command, identity) {
+  const props = projectIdentityProperties(identity);
+  if (!identity.projectDirectory || isProjectTelemetryDisabled())
+    return props;
+  for (let node = command;node; node = node.parent ?? undefined) {
+    const resolver = node[CONTEXT_RESOLVER];
+    if (typeof resolver !== "function")
+      continue;
+    try {
+      return {
+        ...await resolver(identity.projectDirectory),
+        ...props
+      };
+    } catch (error) {
+      logSkipped("solution context lookup", error);
+      return props;
+    }
+  }
+  return props;
+}
+function getProjectTelemetryResolver(command) {
+  for (let node = command;node; node = node.parent) {
+    const resolver = node[RESOLVER];
+    if (typeof resolver === "function")
+      return resolver;
+  }
+  return;
+}
+function attachProjectTelemetryCapture(command, capture) {
+  command[CAPTURE] = capture;
+}
+class ProjectTelemetrySession {
+  resolver;
+  command;
+  target;
+  props = {};
+  explicit = false;
+  input;
+  constructor(resolver, command) {
+    this.resolver = resolver;
+    this.command = command;
+  }
+  async setTarget(path) {
+    this.target = path;
+    if (this.input) {
+      await this.resolve({
+        ...this.input,
+        phase: "after",
+        success: true
+      });
+      this.explicit = true;
+    }
+  }
+  async setIdentity(identity) {
+    try {
+      const props = await bounded(identityWithContext(this.command, identity), "project identity capture");
+      if (props !== undefined)
+        this.setProperties(props);
+    } catch (error) {
+      logSkipped("project identity capture", error);
+    }
+  }
+  setProperties(properties) {
+    try {
+      this.props = { ...properties };
+      this.explicit = true;
+    } catch (error) {
+      logSkipped("project identity properties", error);
+    }
+  }
+  properties() {
+    return { ...this.props };
+  }
+  async resolve(input) {
+    this.input = input;
+    if (this.explicit)
+      return;
+    try {
+      const props = await bounded(this.resolver({
+        ...input,
+        target: this.target
+      }), `project identity (${input.phase})`);
+      if (props !== undefined) {
+        this.props = props;
+      }
+    } catch (error) {
+      logSkipped(`project identity (${input.phase})`, error);
+    }
+  }
+}
 
 // ../common/src/telemetry/command-attribution.ts
 var LEGACY_SKILL_NAMESPACE = "uipath:";
@@ -5314,8 +6254,7 @@ var pollSignalSlot = singleton("PollSignal");
 var TELEMETRY_COMMAND_ARG_PREFIX = "uip.cmd.arg.";
 var processContext = {
   exit: (code) => {
-    recordExitCode(code);
-    setExitCode(code);
+    recordCommandExit(code);
   },
   get pollSignal() {
     return pollSignalSlot.get();
@@ -5340,6 +6279,8 @@ function recordableArgValue(value, choices) {
 function extractCommandParams(cmd) {
   const params = {};
   forEachSuppliedArgument(cmd, (name, value, choices, defaulted) => {
+    if (name === undefined)
+      return;
     const recordable = recordableArgValue(value, choices);
     params[`${TELEMETRY_COMMAND_ARG_PREFIX}${name}`] = recordable === TELEMETRY_ARG_VALUE_WITHHELD && defaulted ? TELEMETRY_ARG_VALUE_DEFAULTED : recordable;
   });
@@ -5355,7 +6296,8 @@ function isDefaultedPositional(cmd, index) {
 function forEachSuppliedArgument(cmd, visit) {
   const registered = cmd.registeredArguments ?? [];
   const processed = cmd.processedArgs ?? [];
-  for (let i = 0;i < registered.length; i++) {
+  const bound = boundPositionalCount(cmd);
+  for (let i = 0;i < bound; i++) {
     const name = registered[i].name();
     if (name && processed[i] !== undefined) {
       visit(name, processed[i], registered[i].argChoices, isDefaultedPositional(cmd, i));
@@ -5370,6 +6312,71 @@ function forEachSuppliedArgument(cmd, visit) {
       visit(key, value, choicesByAttribute.get(key), isDefaultedOption(cmd, key));
     }
   }
+  forEachPassThroughToken(cmd, bound, (name, value) => {
+    visit(name, value, name === undefined ? undefined : choicesByAttribute.get(name), false);
+  });
+}
+function boundPositionalCount(cmd) {
+  const registered = cmd.registeredArguments ?? [];
+  if (registered.some((argument) => argument.variadic)) {
+    return registered.length;
+  }
+  if ((cmd.args ?? []).length <= registered.length) {
+    return registered.length;
+  }
+  const firstFlag = tokenizeTail(cmd, (cmd.args ?? []).slice(1)).tokens.find((token) => token.kind !== "operand")?.index ?? -1;
+  return firstFlag === -1 ? registered.length : Math.min(registered.length, firstFlag + 1);
+}
+function forEachPassThroughToken(cmd, bound, visit) {
+  const registered = cmd.registeredArguments ?? [];
+  const fillsPositionals = !registered.some((argument) => argument.variadic);
+  const { tokens, firstUnknown } = tokenizeTail(cmd, (cmd.args ?? []).slice(bound));
+  const repeated = new Map;
+  let nextPositional = bound;
+  for (const token of tokens) {
+    const pastUnknown = firstUnknown !== -1 && token.index > firstUnknown;
+    if (token.kind === "sentinel")
+      continue;
+    if (token.kind === "operand") {
+      const claimable = !pastUnknown && fillsPositionals && nextPositional < registered.length;
+      const name = claimable ? registered[nextPositional++].name() : undefined;
+      visit(name || undefined, token.text);
+      continue;
+    }
+    if (token.kind === "unknown") {
+      const bare = token.flag.replace(/^-+/, "");
+      const key = bare.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const keyable = token.flag.startsWith("--") || token.flag.length === 2;
+      if (!pastUnknown && keyable && /^[a-z][a-z0-9-]*$/i.test(bare) && key) {
+        visit(key, token.inlineValue ?? true);
+      } else {
+        visit(undefined, token.text);
+        if (token.inlineValue !== undefined) {
+          visit(undefined, token.inlineValue);
+        } else if (!token.flag.startsWith("--") && token.flag.length > 2) {
+          visit(undefined, token.flag.slice(2));
+        }
+      }
+      continue;
+    }
+    if (pastUnknown) {
+      visit(undefined, token.text);
+      if (token.value !== undefined)
+        visit(undefined, token.value);
+      continue;
+    }
+    const option = token.option;
+    const name = option.attributeName();
+    const value = option.negate ? false : option.required || option.optional ? token.value ?? true : true;
+    const previous = repeated.get(name);
+    if (previous) {
+      previous.push(value);
+      visit(name, previous);
+    } else {
+      repeated.set(name, [value]);
+      visit(name, value);
+    }
+  }
 }
 function withheldArgumentValues(cmd) {
   const values = [];
@@ -5420,7 +6427,7 @@ function implicitLimitViolation(cmd) {
 function exitCodeFromProcess(fallback) {
   return typeof process.exitCode === "number" ? process.exitCode : fallback;
 }
-Command.prototype.trackedAction = function(context, fn, properties) {
+Command2.prototype.trackedAction = function(context, fn, properties) {
   const command = this;
   return this.action(async (...args) => {
     await loadOutputCodecsAsync({
@@ -5431,6 +6438,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     const telemetryName = commandTelemetryName(commandParts);
     const commandPath = commandInvocationPath(commandParts);
     const props = typeof properties === "function" ? properties(...args) : properties;
+    const projectResolver = getProjectTelemetryResolver(command);
+    const projectSession = projectResolver && !isProjectTelemetryDisabled() ? new ProjectTelemetrySession(projectResolver, command) : undefined;
     markCommandStart();
     const supplied = recordSuppliedArgumentValues(withheldArgumentValues(command));
     try {
@@ -5438,11 +6447,17 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       let errorMessage;
       let fallbackExitCode = EXIT_CODES.Success;
       clearRecordedCommandFailureTelemetry();
-      const [error] = await catchError(ensureInvocationRequestScope(() => {
+      const [error] = await catchError2(ensureInvocationRequestScope(() => {
         const violation = implicitLimitViolation(command);
         if (violation) {
           return Promise.reject(violation);
         }
+        if (projectSession) {
+          return projectSession.resolve({ command, args, phase: "before" }).then(() => {
+            attachProjectTelemetryCapture(command, projectSession);
+            return fn(...args);
+          });
+        }
         return fn(...args);
       }));
       if (error) {
@@ -5451,22 +6466,26 @@ Command.prototype.trackedAction = function(context, fn, properties) {
         const typed = error;
         const customInstructions = typeof typed.instructions === "string" ? typed.instructions : undefined;
         const customResult = typeof typed.result === "string" && typed.result !== RESULTS.Success && Object.values(RESULTS).includes(typed.result) ? typed.result : undefined;
-        const finalResult = customResult ?? RESULTS.Failure;
+        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
+        const classified = cancellationExitCode === undefined ? await extractErrorDetails(error) : undefined;
+        const finalResult = customResult ?? classified?.result ?? RESULTS.Failure;
         const typedErrorCode = typed.errorCode ?? typed.ErrorCode;
         const customErrorCode = isCliErrorCode(typedErrorCode) ? typedErrorCode : undefined;
         const typedRetry = typed.retry ?? typed.Retry;
         const customRetry = isRetryHint(typedRetry) ? typedRetry : undefined;
         const typedContext = typed.context ?? typed.Context;
         const customContext = isErrorContext(typedContext) ? typedContext : undefined;
-        const cancellationExitCode = typed.exitCode === 130 || isPromptCancellation(error) ? 130 : undefined;
         fallbackExitCode = cancellationExitCode ?? EXIT_CODES[finalResult];
+        const errorCode = customErrorCode ?? classified?.errorCode;
+        const retry = customRetry ?? classified?.retry;
+        const errorContext = customContext ?? classified?.context;
         OutputFormatter.error({
           Result: finalResult,
-          ...customErrorCode ? { ErrorCode: customErrorCode } : {},
+          ...errorCode ? { ErrorCode: errorCode } : {},
           Message: errorMessage,
           Instructions: customInstructions ?? commandHelpHint(commandPath),
-          ...customRetry ? { Retry: customRetry } : {},
-          ...customContext ? { Context: customContext } : {}
+          ...retry ? { Retry: retry } : {},
+          ...errorContext ? { Context: errorContext } : {}
         });
         context.exit(fallbackExitCode);
       }
@@ -5475,6 +6494,14 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
       const recordedFailure = takeRecordedCommandFailureTelemetry();
       const success = !error && exitCode === 0;
+      if (projectSession) {
+        await projectSession.resolve({
+          command,
+          args,
+          phase: "after",
+          success
+        });
+      }
       const terminalTelemetry = buildCommandTerminalTelemetryProperties({
         error,
         exitCode,
@@ -5492,6 +6519,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       }
       const baseProperties = redactProperties({
         ...commandParams,
+        ...projectSession?.properties(),
         ...props,
         ...buildCommandTelemetryAttribution(commandPath, process.env.UIPATH_SKILL),
         ...buildAgentSessionTelemetry(process.env),
@@ -5502,6 +6530,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       });
       emitInvocationRequest(telemetryName, success, baseProperties);
     } finally {
+      if (projectSession)
+        attachProjectTelemetryCapture(command, undefined);
       releaseSuppliedArgumentValues(supplied);
     }
   });
@@ -5620,7 +6650,7 @@ function unsupportedSolutionProjectType(projectType) {
 }
 // ../common/src/command-examples.ts
 var examplesByCommand = new WeakMap;
-Command.prototype.examples = function(examples) {
+Command2.prototype.examples = function(examples) {
   examplesByCommand.set(this, examples);
   return this;
 };
@@ -5629,11 +6659,11 @@ var previewSlot = singleton("PreviewBuild");
 function isPreviewBuild() {
   return previewSlot.get(false) ?? false;
 }
-Command.prototype.previewCommand = function(nameAndArgs, opts) {
+Command2.prototype.previewCommand = function(nameAndArgs, opts) {
   if (isPreviewBuild()) {
     return this.command(nameAndArgs, opts);
   }
-  return new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
+  return new Command2(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
 };
 // ../common/src/completer.ts
 var COMPLETER_SYMBOL = Symbol.for("@uipath/common/completer");
@@ -5983,18 +7013,43 @@ function withPseudonymizedIdentifiers(payload) {
     }
   };
 }
-function trackShipSucceeded(payload) {
+function identityKeysOf(capture) {
+  if (!capture) {
+    return {};
+  }
+  try {
+    const properties = capture.properties?.();
+    if (typeof properties !== "object" || properties === null) {
+      return {};
+    }
+    const keys = {};
+    for (const key of GUID_KEY_DIMENSIONS) {
+      const value = properties[key];
+      if (value !== undefined) {
+        keys[key] = value;
+      }
+    }
+    return keys;
+  } catch (error) {
+    logSkipped("ship identity", error);
+    return {};
+  }
+}
+function trackShipSucceeded(payload, capture) {
   const keys = getShippedKeys();
   const key = dedupeKey(payload);
   if (keys.has(key)) {
     return false;
   }
   keys.add(key);
-  telemetry.trackEvent(CommonTelemetryEvents.ShipSucceeded, redactProperties(withPseudonymizedIdentifiers(payload)));
+  telemetry.trackEvent(CommonTelemetryEvents.ShipSucceeded, redactProperties({
+    ...withPseudonymizedIdentifiers(payload),
+    ...identityKeysOf(capture)
+  }));
   return true;
 }
 // ../common/src/tool-provider.ts
 var factorySlot = singleton("PackagerFactoryProvider");
-export { catchError, getOutputSink, logger, getOutputFormat, getOutputFormatExplicit, CommandDimensions, ShipDimensions, RESULTS, OutputFormatter, summarizePlatformBody, Option, processContext, UIPATH_HOME_DIR, stripHostGlobalOptions, createHiddenDeprecatedTenantOption, ScreenLogger, getSdkUserAgentToken, addSdkUserAgentHeader, installSdkUserAgentHeader, quoteForShell, unsupportedSolutionProjectType, trackShipSucceeded };
+export { getFileSystem, CommandDimensions, ShipDimensions, catchError2, RESULTS, Option, getOutputSink, logger, getOutputFormat, getOutputFormatExplicit, OutputFormatter, processContext, UIPATH_HOME_DIR, stripHostGlobalOptions, createHiddenDeprecatedTenantOption, ScreenLogger, getSdkUserAgentToken, installSdkUserAgentHeader, quoteForShell, unsupportedSolutionProjectType, trackShipSucceeded };
 
-//# debugId=56A31FF974DBA38964756E2164756E21
+//# debugId=31FB79DD99632B8864756E2164756E21