@uipath/insights-tool 1.201.0 → 1.202.0-preview.136

package/dist/{tool-xmkb1ctj.js → tool-dcpxje5e.js}

@@ -1,23 +1,11 @@
-import {
-  isBrowser
-} from "./tool-9qecd4wb.js";
-import {
-  catchError,
-  getFileSystem
-} from "./tool-7eva0peq.js";
-import {
-  AUTH_FILENAME,
-  DEFAULT_BASE_URL,
-  UIPATH_HOME_DIR
-} from "./tool-5arsyj36.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./tool-0v6na3yp.js";
+} from "./tool-1de529jm.js";
 
 // ../../node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
+var require_error = __commonJS(function(exports) {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
       super(message);
@@ -41,7 +29,7 @@ var require_error = __commonJS((exports) => {
 });
 
 // ../../node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
+var require_argument = __commonJS(function(exports) {
   var { InvalidArgumentError } = require_error();
 
   class Argument {
@@ -121,7 +109,7 @@ var require_argument = __commonJS((exports) => {
 });
 
 // ../../node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
+var require_help = __commonJS(function(exports) {
   var { humanReadableArgName } = require_argument();
 
   class Help {
@@ -478,7 +466,7 @@ ${itemIndentStr}`);
 });
 
 // ../../node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
+var require_option = __commonJS(function(exports) {
   var { InvalidArgumentError } = require_error();
 
   class Option {
@@ -662,7 +650,7 @@ var require_option = __commonJS((exports) => {
 });
 
 // ../../node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
+var require_suggestSimilar = __commonJS(function(exports) {
   var maxDistance = 3;
   function editDistance(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
@@ -735,11 +723,11 @@ var require_suggestSimilar = __commonJS((exports) => {
 });
 
 // ../../node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
+var require_command = __commonJS(function(exports) {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
-  var path = __require("node:path");
-  var fs = __require("node:fs");
+  var path2 = __require("node:path");
+  var fs2 = __require("node:fs");
   var process2 = __require("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
@@ -1274,7 +1262,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = [];
     }
     _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
+      if (fs2.existsSync(executableFile))
         return;
       const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
       const executableMissing = `'${executableFile}' does not exist
@@ -1288,12 +1276,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let launchWithNode = false;
       const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
       function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
+        const localBin = path2.resolve(baseDir, baseName);
+        if (fs2.existsSync(localBin))
           return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
+        if (sourceExt.includes(path2.extname(baseName)))
           return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+        const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
         if (foundExt)
           return `${localBin}${foundExt}`;
         return;
@@ -1305,23 +1293,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._scriptPath) {
         let resolvedScriptPath;
         try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
+          resolvedScriptPath = fs2.realpathSync(this._scriptPath);
         } catch {
           resolvedScriptPath = this._scriptPath;
         }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+        executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
       }
       if (executableDir) {
         let localFile = findFile(executableDir, executableFile);
         if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+          const legacyName = path2.basename(this._scriptPath, path2.extname(this._scriptPath));
           if (legacyName !== this._name) {
             localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
           }
         }
         executableFile = localFile || executableFile;
       }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
+      launchWithNode = sourceExt.includes(path2.extname(executableFile));
       let proc;
       if (process2.platform !== "win32") {
         if (launchWithNode) {
@@ -1910,13 +1898,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd.helpGroup(this._defaultCommandGroup);
     }
     nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
+      this._name = path2.basename(filename, path2.extname(filename));
       return this;
     }
-    executableDir(path2) {
-      if (path2 === undefined)
+    executableDir(path3) {
+      if (path3 === undefined)
         return this._executableDir;
-      this._executableDir = path2;
+      this._executableDir = path3;
       return this;
     }
     helpInformation(contextOptions) {
@@ -2090,7 +2078,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 });
 
 // ../../node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
+var require_commander = __commonJS(function(exports) {
   var { Argument } = require_argument();
   var { Command } = require_command();
   var { CommanderError, InvalidArgumentError } = require_error();
@@ -2112,7 +2100,7 @@ var require_commander = __commonJS((exports) => {
 var package_default = {
   name: "@uipath/insights-tool",
   license: "MIT",
-  version: "1.201.0",
+  version: "1.202.0-preview.136",
   description: "Query UiPath Insights data — jobs, failures, and performance metrics.",
   private: false,
   repository: {
@@ -2153,123 +2141,402 @@ var package_default = {
   }
 };
 
-// ../common/src/catch-error.ts
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
-}
-function catchError2(fnOrPromise) {
-  if (isPromiseLike(fnOrPromise)) {
-    return settlePromiseLike(fnOrPromise);
+// ../filesystem/src/node.ts
+import { 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;
+
+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-sby22td6.js");
+      await open(url);
+    }
+  };
+  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;
+    }
   }
-  try {
-    const result = fnOrPromise();
-    if (isPromiseLike(result)) {
-      return settlePromiseLike(result);
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
     }
-    return [undefined, result];
-  } catch (error) {
-    return [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ];
+    await fs.writeFile(filePath, data);
   }
-}
-function settlePromiseLike(thenable) {
-  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
-    error instanceof Error ? error : new Error(String(error)),
-    undefined
-  ]);
-}
-
-// ../common/src/error-handler.ts
-var NETWORK_ERROR_CODES = new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EAI_AGAIN",
-  "ETIMEDOUT",
-  "EPIPE",
-  "EHOSTUNREACH",
-  "ENETUNREACH",
-  "EAI_FAIL"
-]);
-var TLS_ERROR_CODES = new Set([
-  "SELF_SIGNED_CERT_IN_CHAIN",
-  "DEPTH_ZERO_SELF_SIGNED_CERT",
-  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
-  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
-  "UNABLE_TO_GET_ISSUER_CERT",
-  "CERT_HAS_EXPIRED",
-  "CERT_UNTRUSTED",
-  "ERR_TLS_CERT_ALTNAME_INVALID"
-]);
-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_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
-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_CODES.has(code)) {
-      return {
-        code,
-        kind: "tls",
-        message: message ?? code,
-        instructions: TLS_INSTRUCTIONS
-      };
+  async appendFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
     }
-    if (code && NETWORK_ERROR_CODES.has(code)) {
+    await fs.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
       return {
-        code,
-        kind: "network",
-        message: message ?? code,
-        instructions: NETWORK_INSTRUCTIONS
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
       };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
     }
   }
-  return;
+  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));
+      }
+    }
+  }
+  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;
+      }
+      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 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;
+  }
 }
-function* walkErrorGraph(error) {
-  const queue = [error];
-  const seen = new Set;
-  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
-    const current = queue.shift();
-    if (current === null || typeof current !== "object")
-      continue;
-    if (seen.has(current))
-      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);
+
+// ../filesystem/src/index.ts
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => fsInstance;
+
+// ../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;
   }
-  return;
+  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);
 }
-// ../../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/command-examples.ts
-var examplesByCommand = new WeakMap;
-Command.prototype.examples = function(examples) {
-  examplesByCommand.set(this, examples);
-  return this;
-};
 // ../common/src/singleton.ts
 var PREFIX = "@uipath/common/";
 var _g = globalThis;
@@ -2300,82 +2567,480 @@ function singleton(ctorOrName) {
   };
 }
 
-// ../common/src/preview.ts
-var previewSlot = singleton("PreviewBuild");
-function isPreviewBuild() {
-  return previewSlot.get(false) ?? false;
+// ../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;
 }
-Command.prototype.previewCommand = function(nameAndArgs, opts) {
-  if (isPreviewBuild()) {
-    return this.command(nameAndArgs, opts);
-  }
-  return new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
-};
-
-// ../common/src/output-context.ts
-function createStorage() {
-  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;
+function releaseSuppliedArgumentValues(entry) {
+  suppliedValuesSlot.set(activeEntries().filter((held) => held !== entry));
 }
-var storageSingleton = singleton("OutputStorage");
-var sinkSlot = singleton("OutputSink");
-var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
-var CONSOLE_FALLBACK = {
-  writeOut: (str) => process.stdout.write(str),
-  writeErr: (str) => process.stderr.write(str),
-  writeLog: (str) => process.stdout.write(str),
-  capabilities: {
-    isInteractive: false,
-    canReadInput: false,
-    supportsColor: false,
-    outputWidth: 80
+function getSuppliedArgumentValues() {
+  const all = new Set;
+  for (const entry of activeEntries()) {
+    for (const value of entry.values) {
+      all.add(value);
+    }
   }
-};
-function getOutputSink() {
-  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
+  return [...all].sort((a, b) => b.length - a.length);
 }
 
-// ../common/src/logger.ts
-var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path) {
-  logFilePathSlot.set(path);
-}
-function getGlobalLogFilePath() {
-  return logFilePathSlot.get("");
+// ../common/src/telemetry/pii-redactor.ts
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 280;
+var MAX_STACK_LENGTH = 4096;
+var MAX_SCAN_LENGTH = MAX_STACK_LENGTH;
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}…` : value;
 }
-var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
-
-class SimpleLogger {
-  __brand = "SimpleLogger";
-  level;
-  logFilePath;
-  fileLoggingEnabled;
-  pendingWrites = Promise.resolve();
-  pendingInit = Promise.resolve();
-  constructor() {
-    this.level = SimpleLogger.resolveLevel();
-    this.logFilePath = "";
-    this.fileLoggingEnabled = false;
-  }
-  static getInstance() {
-    return loggerSingleton.getOrInit(() => new SimpleLogger, (v) => ("__brand" in v) && v.__brand === "SimpleLogger");
-  }
-  static resetInstance() {
-    loggerSingleton.clear();
-  }
-  static isNode = typeof process !== "undefined" && !!process.versions?.node;
-  static resolveLevel() {
-    if (SimpleLogger.isNode) {
-      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIP_LOG_LEVEL ?? "");
-      if (explicitLevel !== undefined)
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
+var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
+var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
+var HOST_PORT_PATTERN = /(?<![/@.\w-])(?!\d+\.\d+\.\d+\.\d+:)[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)+:\d{1,5}\b/g;
+var SOURCE_FILE_EXTENSIONS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "cts",
+  "mts",
+  "py",
+  "cs",
+  "java",
+  "go",
+  "rs",
+  "rb",
+  "php",
+  "sh",
+  "ps1",
+  "json",
+  "jsonc",
+  "yaml",
+  "yml",
+  "xml",
+  "xaml",
+  "md",
+  "txt",
+  "log",
+  "css",
+  "html",
+  "htm",
+  "csproj",
+  "nuspec",
+  "sql"
+]);
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var QUOTED_LITERAL_MAX_SPAN = 200;
+var QUOTED_LITERAL_PATTERN = new RegExp([
+  `(?<![A-Za-z0-9])'(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?'(?![A-Za-z0-9])`,
+  `(?<![A-Za-z0-9])"(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
+].join("|"), "g");
+var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var COLLAPSED_BODY = "{…}";
+var COLLAPSED_BODY_MARKER = "\x01body\x01";
+var MAX_BODY_NESTING = 8;
+function collapseJsonBodies(text) {
+  let out = text;
+  for (let pass = 0;pass < MAX_BODY_NESTING; pass++) {
+    const next = out.replace(JSON_BODY_PATTERN, COLLAPSED_BODY_MARKER);
+    if (next === out) {
+      break;
+    }
+    out = next;
+  }
+  return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
+}
+var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+function peelTrailingPunctuation(match) {
+  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
+  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${pseudonymize(raw)}`;
+  }
+}
+function redactValueDetectors(value, maxLength = MAX_VALUE_LENGTH) {
+  let out = truncate(value, MAX_SCAN_LENGTH);
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const [core, trailing] = peelTrailingPunctuation(match);
+    return `${redactUrl(core)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(UNC_PATH_PATTERN, (_match, before, path2) => {
+    const [core, trailing] = peelTrailingPunctuation(path2);
+    return `${before}unc#${pseudonymize(core)}${trailing}`;
+  });
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${pseudonymize(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${pseudonymize(match)}`);
+  out = out.replace(HOST_PORT_PATTERN, (match) => {
+    const split = match.lastIndexOf(":");
+    const host = match.slice(0, split);
+    const extension = host.slice(host.lastIndexOf(".") + 1).toLowerCase();
+    if (SOURCE_FILE_EXTENSIONS.has(extension)) {
+      return match;
+    }
+    return `host#${pseudonymize(host)}:${match.slice(split + 1)}`;
+  });
+  out = out.replace(PADDED_BASE64_PATTERN, () => REDACTED);
+  out = out.replace(BASE64_WITH_PLUS_PATTERN, (match) => match.includes("+") ? REDACTED : match);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  return truncate(out, maxLength);
+}
+function redactSpanName(name) {
+  return redactValueDetectors(truncate(name, MAX_SCAN_LENGTH).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`));
+}
+var HTTP_DEPENDENCY_NAME = /^([A-Z]+) (\/.*)$/s;
+function redactHttpDependencyName(name) {
+  const parts = HTTP_DEPENDENCY_NAME.exec(name);
+  if (!parts) {
+    return redactMessage(name);
+  }
+  return `${parts[1]} ${redactMessage(parts[2])}`;
+}
+function redactMessage(value) {
+  let out = collapseJsonBodies(truncate(value, MAX_SCAN_LENGTH)).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`);
+  for (const supplied of getSuppliedArgumentValues()) {
+    out = out.split(supplied).join(REDACTED);
+  }
+  return redactValueDetectors(out);
+}
+var MESSAGE_NAMES = new Set([
+  "message",
+  "errormessage",
+  "errmessage",
+  "error_message",
+  "msg",
+  "detail",
+  "details",
+  "reason",
+  "instructions",
+  "warning"
+]);
+function isFreeFormValue(name, value) {
+  return MESSAGE_NAMES.has(name.toLowerCase()) || /['"{[]/.test(value);
+}
+function redactError(error) {
+  const safe = new Error(redactMessage(error.message ?? ""));
+  safe.name = error.name;
+  safe.stack = typeof error.stack === "string" ? redactStack(error.stack) : undefined;
+  return safe;
+}
+function redactStack(stack) {
+  const bounded = truncate(stack, MAX_STACK_LENGTH);
+  const firstBreak = bounded.indexOf(`
+`);
+  if (firstBreak === -1) {
+    return redactMessage(bounded);
+  }
+  return `${redactMessage(bounded.slice(0, firstBreak))}
+${redactValueDetectors(bounded.slice(firstBreak + 1), MAX_STACK_LENGTH)}`;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return isFreeFormValue(name, value) ? redactMessage(value) : redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+
+// ../common/src/catch-error.ts
+var MAX_SERIALIZED_LENGTH = 500;
+var TRUNCATION_SUFFIX = "…(truncated)";
+var REDACTED2 = "[REDACTED]";
+function cap(text) {
+  return text.length > MAX_SERIALIZED_LENGTH ? `${text.slice(0, MAX_SERIALIZED_LENGTH)}${TRUNCATION_SUFFIX}` : text;
+}
+function omitSensitive(key, value) {
+  return key.length > 0 && isSensitiveName(key) ? REDACTED2 : value;
+}
+function describeThrownValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value);
+  }
+  let message;
+  try {
+    message = value.message;
+  } catch {
+    message = undefined;
+  }
+  if (typeof message === "string" && message.length > 0) {
+    return cap(message);
+  }
+  try {
+    const json = JSON.stringify(value, omitSensitive);
+    if (json !== undefined) {
+      return cap(json);
+    }
+  } catch {}
+  return String(value);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(describeThrownValue(error), { cause: error });
+}
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [toError(error), undefined];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
+}
+
+// ../common/src/error-handler.ts
+var NETWORK_ERROR_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EAI_FAIL"
+]);
+var TLS_ERROR_CODES = new Set([
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_GET_ISSUER_CERT",
+  "CERT_HAS_EXPIRED",
+  "CERT_UNTRUSTED",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+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_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
+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_CODES.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* walkErrorGraph(error) {
+  const queue = [error];
+  const seen = new Set;
+  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
+    const current = queue.shift();
+    if (current === null || typeof current !== "object")
+      continue;
+    if (seen.has(current))
+      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;
+}
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
+}
+
+// ../common/src/output-context.ts
+function createStorage() {
+  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 storageSingleton = singleton("OutputStorage");
+var sinkSlot = singleton("OutputSink");
+var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
+var CONSOLE_FALLBACK = {
+  writeOut: (str) => process.stdout.write(str),
+  writeErr: (str) => process.stderr.write(str),
+  writeLog: (str) => process.stdout.write(str),
+  capabilities: {
+    isInteractive: false,
+    canReadInput: false,
+    supportsColor: false,
+    outputWidth: 80
+  }
+};
+function getOutputSink() {
+  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
+}
+
+// ../common/src/logger.ts
+var logFilePathSlot = singleton("logFilePath");
+function setGlobalLogFilePath(path2) {
+  logFilePathSlot.set(path2);
+}
+function getGlobalLogFilePath() {
+  return logFilePathSlot.get("");
+}
+var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
+
+class SimpleLogger {
+  __brand = "SimpleLogger";
+  level;
+  logFilePath;
+  fileLoggingEnabled;
+  pendingWrites = Promise.resolve();
+  pendingInit = Promise.resolve();
+  constructor() {
+    this.level = SimpleLogger.resolveLevel();
+    this.logFilePath = "";
+    this.fileLoggingEnabled = false;
+  }
+  static getInstance() {
+    return loggerSingleton.getOrInit(() => new SimpleLogger, (v) => ("__brand" in v) && v.__brand === "SimpleLogger");
+  }
+  static resetInstance() {
+    loggerSingleton.clear();
+  }
+  static isNode = typeof process !== "undefined" && !!process.versions?.node;
+  static resolveLevel() {
+    if (SimpleLogger.isNode) {
+      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIP_LOG_LEVEL ?? "");
+      if (explicitLevel !== undefined)
         return explicitLevel;
       const debugVal = process.env?.DEBUG;
       if (debugVal === "true" || debugVal === "1") {
@@ -2383,7 +3048,7 @@ class SimpleLogger {
       }
       return DEFAULT_LOG_LEVEL;
     }
-    const [localStorageError, hasDebug] = catchError2(() => typeof localStorage !== "undefined" && !!localStorage.getItem("debug"));
+    const [localStorageError, hasDebug] = catchError(() => typeof localStorage !== "undefined" && !!localStorage.getItem("debug"));
     if (!localStorageError && hasDebug) {
       return 0 /* DEBUG */;
     }
@@ -2414,54 +3079,49 @@ class SimpleLogger {
     return this.fileLoggingEnabled || !!getGlobalLogFilePath();
   }
   writeToFile(formatted) {
-    const path = this.logFilePath || getGlobalLogFilePath();
-    if (!path)
+    const path2 = this.logFilePath || getGlobalLogFilePath();
+    if (!path2)
       return;
     const timestamp = new Date().toISOString();
     this.pendingWrites = Promise.all([
       this.pendingWrites,
       this.pendingInit
-    ]).then(() => getFileSystem().appendFile(path, `${timestamp} ${formatted}`).catch(() => {}));
+    ]).then(() => getFileSystem().appendFile(path2, `${timestamp} ${formatted}`).catch(() => {}));
   }
-  debug(message, ...args) {
-    if (this.level > 0 /* DEBUG */)
-      return;
-    const formatted = this.format(`[DEBUG] ${message}`, args);
+  write(formatted) {
     if (this.isFileLoggingActive()) {
       this.writeToFile(formatted);
     } else {
       getOutputSink().writeErr(formatted);
     }
   }
+  debug(message, ...args) {
+    if (this.level > 0 /* DEBUG */)
+      return;
+    const formatted = this.format(`[DEBUG] ${message}`, args);
+    this.write(formatted);
+  }
   info(message, ...args) {
     if (this.level > 1 /* INFO */)
       return;
     const formatted = this.format(message, args);
-    if (this.isFileLoggingActive()) {
-      this.writeToFile(formatted);
-    } else {
-      getOutputSink().writeErr(formatted);
-    }
+    this.write(formatted);
   }
   warn(message, ...args) {
     if (this.level > 2 /* WARN */)
       return;
     const formatted = this.format(`[WARN] ${message}`, args);
-    if (this.isFileLoggingActive()) {
-      this.writeToFile(formatted);
-    } else {
-      getOutputSink().writeErr(formatted);
-    }
+    this.write(formatted);
   }
   error(message, ...args) {
     if (this.level > 3 /* ERROR */)
       return;
     const formatted = this.format(`[ERROR] ${message}`, args);
-    if (this.isFileLoggingActive()) {
-      this.writeToFile(formatted);
-    } else {
-      getOutputSink().writeErr(formatted);
-    }
+    this.write(formatted);
+  }
+  report(message) {
+    const formatted = this.format(message, []);
+    this.write(formatted);
   }
   getLevel() {
     return this.level;
@@ -2476,17 +3136,17 @@ class SimpleLogger {
       setGlobalLogFilePath("");
     }
   }
-  setLogFile(path) {
-    this.logFilePath = path;
-    setGlobalLogFilePath(path);
-    if (!path)
+  setLogFile(path2) {
+    this.logFilePath = path2;
+    setGlobalLogFilePath(path2);
+    if (!path2)
       return;
     this.fileLoggingEnabled = true;
-    const fs = getFileSystem();
+    const fs2 = getFileSystem();
     this.pendingInit = (async () => {
-      const [error] = await catchError2((async () => {
-        await fs.mkdir(fs.path.dirname(path));
-        await fs.writeFile(path, "");
+      const [error] = await catchError((async () => {
+        await fs2.mkdir(fs2.path.dirname(path2));
+        await fs2.writeFile(path2, "");
       })());
       if (error)
         this.fileLoggingEnabled = false;
@@ -2540,12 +3200,12 @@ var jmespathSlot = singleton("JmespathCodec");
 async function loadOutputCodecsAsync(needed) {
   const loads = [];
   if (needed.yaml && yamlSlot.get() === undefined) {
-    loads.push(import("./js-yaml-4ypbq2tt.js").then((mod) => {
+    loads.push(import("./js-yaml-88tdqrtd.js").then((mod) => {
       yamlSlot.set(mod);
     }));
   }
   if (needed.filter && jmespathSlot.get() === undefined) {
-    loads.push(import("./index-2fj08e7n.js").then((mod) => {
+    loads.push(import("./index-gpd94m28.js").then((mod) => {
       jmespathSlot.set(mod);
     }));
   }
@@ -2800,7 +3460,7 @@ function readRegistryValue(keyPath, valueName) {
   if (process.platform !== "win32") {
     return "";
   }
-  const [error, output] = catchError2(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
+  const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   }));
@@ -2823,27 +3483,41 @@ class LoggerTelemetryProvider {
       ...this.analyticsUniqueId ? { analyticsUniqueId: this.analyticsUniqueId } : {}
     };
   }
-  async trackEvent(eventName, properties) {
-    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
+  async trackEvent({ name, properties }) {
+    logger.debug(formatMessage("Event", name, this.enrich(properties)));
   }
-  async trackException(error, properties) {
+  async trackException({
+    error,
+    properties
+  }) {
     logger.error(formatMessage("Exception", error.message, this.enrich({
       ...properties,
       stack: error.stack
     })));
   }
-  async trackRequest(name, duration, success, properties) {
+  async trackRequest({
+    name,
+    durationMs,
+    success,
+    properties
+  }) {
     logger.debug(formatMessage("Request", name, this.enrich({
       ...properties,
-      duration: `${duration}ms`,
+      duration: `${durationMs}ms`,
       success
     })));
   }
-  async trackDependency(name, type, duration, success, properties) {
+  async trackDependency({
+    name,
+    type,
+    durationMs,
+    success,
+    properties
+  }) {
     logger.debug(formatMessage("Dependency", name, this.enrich({
       ...properties,
       type,
-      duration: `${duration}ms`,
+      duration: `${durationMs}ms`,
       success
     })));
   }
@@ -3047,196 +3721,68 @@ function normalizeSessionId(value) {
     return;
   }
   const cleaned = String(value).replace(CONTROL_CHARACTERS, "").trim().slice(0, SESSION_ID_MAX_LENGTH);
-  return cleaned || undefined;
-}
-function getConfiguredTelemetrySessionId() {
-  return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
-}
-function getInheritedSession(env) {
-  for (const candidate of INHERITED_SESSION_SOURCES) {
-    const handle = normalizeSessionId(env[candidate.envVar]);
-    if (handle) {
-      return { id: handle, source: candidate.source };
-    }
-  }
-  return;
-}
-function generateRandomSession() {
-  const bytes = new Uint8Array(RANDOM_SESSION_ID_LENGTH / 2);
-  crypto.getRandomValues(bytes);
-  let hex = "";
-  for (const byte of bytes) {
-    hex += byte.toString(16).padStart(2, "0");
-  }
-  return { id: hex, source: "random" };
-}
-function resolveTelemetrySession() {
-  const existing = telemetrySessionSlot.get();
-  if (existing) {
-    return existing;
-  }
-  const declaredHandle = getConfiguredTelemetrySessionId();
-  const resolved = declaredHandle ? { id: declaredHandle, source: "declared" } : getInheritedSession(getProcessEnv2() ?? {}) ?? generateRandomSession();
-  telemetrySessionSlot.set(resolved);
-  return resolved;
-}
-function getTelemetrySessionSource() {
-  return resolveTelemetrySession().source;
-}
-function getTelemetryOperationId() {
-  const existing = telemetryOperationIdSlot.get();
-  if (existing) {
-    return existing;
-  }
-  const inboundTraceId = getInboundTraceContext()?.traceId;
-  const generated = inboundTraceId ?? crypto.randomUUID().replaceAll("-", "");
-  telemetryOperationIdSlot.set(generated);
-  return generated;
-}
-// ../common/src/telemetry/global-telemetry-properties.ts
-var telemetryPropsSlot = singleton("TelemetryDefaultProps");
-function getGlobalTelemetryProperties() {
-  return telemetryPropsSlot.get();
-}
-
-// ../common/src/telemetry/pii-redactor.ts
-var REDACTED = "[REDACTED]";
-var MAX_VALUE_LENGTH = 200;
-var SENSITIVE_NAME_TOKENS = new Set([
-  "token",
-  "tokens",
-  "secret",
-  "secrets",
-  "password",
-  "passwords",
-  "pwd",
-  "credential",
-  "credentials",
-  "auth",
-  "authentication",
-  "authorization",
-  "authority",
-  "cert",
-  "certificate",
-  "certificates"
-]);
-var SENSITIVE_KEY_PREFIXES = new Set([
-  "api",
-  "access",
-  "client",
-  "private",
-  "public",
-  "signing",
-  "encryption",
-  "session",
-  "master",
-  "shared",
-  "root",
-  "ssh",
-  "rsa",
-  "aes",
-  "hmac",
-  "oauth"
-]);
-var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
-var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
-var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
-var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
-var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
-function shortHash(input) {
-  let hash = 2166136261;
-  for (let i = 0;i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function redactUrl(raw) {
-  try {
-    const url = new URL(raw);
-    return `${url.protocol}//${url.host}`;
-  } catch {
-    return `url#${shortHash(raw)}`;
-  }
-}
-function redactValueDetectors(value) {
-  let out = value;
-  out = out.replace(JWT_PATTERN, () => REDACTED);
-  out = out.replace(URL_PATTERN, (match) => {
-    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
-    const core = trailing ? match.slice(0, -trailing.length) : match;
-    return `${redactUrl(core)}${trailing}`;
-  });
-  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
-  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
-  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
-  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
-  if (out.length > MAX_VALUE_LENGTH) {
-    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
-  }
-  return out;
-}
-function redactValue(value) {
-  return redactValueDetectors(value);
-}
-function redactError(error) {
-  const safe = new Error(redactValueDetectors(error.message ?? ""));
-  safe.name = error.name;
-  safe.stack = typeof error.stack === "string" ? redactValueDetectors(error.stack) : undefined;
-  return safe;
+  return cleaned || undefined;
 }
-function nameTokens(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+function getConfiguredTelemetrySessionId() {
+  return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
 }
-function isSensitiveName(name) {
-  const tokens = nameTokens(name);
-  for (let i = 0;i < tokens.length; i++) {
-    const token = tokens[i];
-    if (SENSITIVE_NAME_TOKENS.has(token)) {
-      return true;
-    }
-    if (token === "key" || token === "keys") {
-      const prev = tokens[i - 1];
-      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
-        return true;
-      }
+function getInheritedSession(env) {
+  for (const candidate of INHERITED_SESSION_SOURCES) {
+    const handle = normalizeSessionId(env[candidate.envVar]);
+    if (handle) {
+      return { id: handle, source: candidate.source };
     }
   }
-  return false;
+  return;
 }
-function redactProperty(name, value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (isSensitiveName(name)) {
-    return REDACTED;
-  }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return value;
+function generateRandomSession() {
+  const bytes = new Uint8Array(RANDOM_SESSION_ID_LENGTH / 2);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
   }
-  if (typeof value !== "string") {
-    return "[OBJECT]";
+  return { id: hex, source: "random" };
+}
+function resolveTelemetrySession() {
+  const existing = telemetrySessionSlot.get();
+  if (existing) {
+    return existing;
   }
-  return redactValueDetectors(value);
+  const declaredHandle = getConfiguredTelemetrySessionId();
+  const resolved = declaredHandle ? { id: declaredHandle, source: "declared" } : getInheritedSession(getProcessEnv2() ?? {}) ?? generateRandomSession();
+  telemetrySessionSlot.set(resolved);
+  return resolved;
 }
-function redactProperties(properties) {
-  const out = {};
-  for (const [name, value] of Object.entries(properties)) {
-    const redacted = redactProperty(name, value);
-    if (redacted !== undefined) {
-      out[name] = redacted;
-    }
+function getTelemetrySessionSource() {
+  return resolveTelemetrySession().source;
+}
+function getTelemetryOperationId() {
+  const existing = telemetryOperationIdSlot.get();
+  if (existing) {
+    return existing;
   }
-  return out;
+  const inboundTraceId = getInboundTraceContext()?.traceId;
+  const generated = inboundTraceId ?? crypto.randomUUID().replaceAll("-", "");
+  telemetryOperationIdSlot.set(generated);
+  return generated;
+}
+// ../common/src/telemetry/global-telemetry-properties.ts
+var telemetryPropsSlot = singleton("TelemetryDefaultProps");
+function getGlobalTelemetryProperties() {
+  return telemetryPropsSlot.get();
 }
 
-// ../common/src/telemetry/telemetry-service.ts
-var TELEMETRY_OPERATION_ID_PROPERTY = "uip.trace.operation_id";
-var TELEMETRY_PARENT_ID_PROPERTY = "uip.trace.parent_id";
-var TELEMETRY_SPAN_ID_PROPERTY = "uip.trace.span_id";
+// ../common/src/telemetry/span-clock.ts
+function startSpanClock() {
+  const started = performance.now();
+  return {
+    startedAt: new Date(performance.timeOrigin + started),
+    elapsedMs: () => performance.now() - started
+  };
+}
 
+// ../common/src/telemetry/telemetry-service.ts
 class TelemetryService {
   telemetryProvider;
   contextStorage;
@@ -3256,36 +3802,39 @@ class TelemetryService {
     this.defaultProperties = properties === undefined ? undefined : { ...this.defaultProperties, ...properties };
   }
   trackEvent(name, properties) {
-    const context = this.getCurrentContext();
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackEvent(name, enrichedProperties);
+    this.telemetryProvider.trackEvent({
+      name: redactSpanName(name),
+      properties: this.enrichProperties(properties),
+      ...this.leafCorrelation()
+    });
   }
-  trackException(error, properties) {
-    const context = this.getCurrentContext();
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackException(redactError(error), enrichedProperties);
+  trackException(error, properties, context) {
+    this.telemetryProvider.trackException({
+      error: redactError(error),
+      properties: this.enrichProperties(properties),
+      ...this.leafCorrelation(context)
+    });
   }
   async trackRequest(name, fn, properties) {
-    const parentContext = this.getCurrentContext();
+    const parentContext = this.getActiveContext();
     const operationId = parentContext?.operationId ?? this.operationId ?? getTelemetryOperationId();
     const parentId = parentContext ? parentContext.id : this.inboundParentIdFor(operationId);
+    const clock = startSpanClock();
     const context = {
       operationId,
       ...parentId !== undefined ? { parentId } : {},
-      id: this.generateId()
+      id: this.generateId(),
+      startedAt: clock.startedAt
     };
-    const startTime = performance.now();
     try {
       const result = await this.contextStorage.run(context, fn);
-      const durationMs = performance.now() - startTime;
-      const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-      await this.telemetryProvider.trackRequest(name, durationMs, true, enrichedProperties);
+      const durationMs = clock.elapsedMs();
+      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, true, properties, context));
       return result;
     } catch (error) {
-      const durationMs = performance.now() - startTime;
+      const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
-      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, context);
-      await this.telemetryProvider.trackRequest(name, durationMs, false, enrichedProperties);
+      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, context));
       throw error;
     }
   }
@@ -3294,8 +3843,7 @@ class TelemetryService {
       operationId: this.operationId ?? getTelemetryOperationId(),
       id: this.generateId()
     };
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, requestContext);
-    this.telemetryProvider.trackRequest(name, durationMs, success, enrichedProperties);
+    this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, success, properties, requestContext));
   }
   createRequestContext() {
     const operationId = this.operationId ?? getTelemetryOperationId();
@@ -3303,7 +3851,8 @@ class TelemetryService {
     return {
       operationId,
       ...parentId !== undefined ? { parentId } : {},
-      id: this.generateId()
+      id: this.generateId(),
+      startedAt: startSpanClock().startedAt
     };
   }
   inboundParentIdFor(operationId) {
@@ -3314,58 +3863,84 @@ class TelemetryService {
     return this.contextStorage.run(context, fn);
   }
   createDependencyContext() {
-    const parentContext = this.getCurrentContext();
+    const parentContext = this.getActiveContext();
     if (!parentContext) {
       return;
     }
     return {
       operationId: parentContext.operationId,
       parentId: parentContext.id,
-      id: this.generateId()
+      id: this.generateId(),
+      startedAt: startSpanClock().startedAt
     };
   }
   trackDependencyResult(name, type, durationMs, success, properties, context, resultCode) {
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackDependency(redactValue(name), type, durationMs, success, enrichedProperties, resultCode);
+    this.telemetryProvider.trackDependency({
+      ...this.spanFor(redactHttpDependencyName(name), durationMs, success, properties, context),
+      type,
+      ...resultCode !== undefined ? { resultCode } : {}
+    });
   }
   async trackDependencyOperation(name, type, fn, properties) {
-    const parentContext = this.getCurrentContext();
+    const clock = startSpanClock();
+    const parentContext = this.getActiveContext();
     const childContext = parentContext !== undefined ? {
       operationId: parentContext.operationId,
       parentId: parentContext.id,
-      id: this.generateId()
-    } : this.createRequestContext();
-    const startTime = performance.now();
+      id: this.generateId(),
+      startedAt: clock.startedAt
+    } : {
+      ...this.createRequestContext(),
+      startedAt: clock.startedAt
+    };
     try {
       const result = await this.contextStorage.run(childContext, fn);
-      const durationMs = performance.now() - startTime;
-      const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
-      await this.telemetryProvider.trackDependency(name, type, durationMs, true, enrichedProperties);
+      const durationMs = clock.elapsedMs();
+      await this.telemetryProvider.trackDependency({
+        ...this.spanFor(name, durationMs, true, properties, childContext),
+        type
+      });
       return result;
     } catch (error) {
-      const durationMs = performance.now() - startTime;
+      const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
-      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, childContext);
-      await this.telemetryProvider.trackDependency(name, type, durationMs, false, enrichedProperties);
+      await this.telemetryProvider.trackDependency({
+        ...this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, childContext),
+        type
+      });
       throw error;
     }
   }
-  getCurrentContext() {
+  getActiveContext() {
     return this.contextStorage.getContext();
   }
-  enrichPropertiesWithContext(properties, context) {
+  leafCorrelation(explicit) {
+    const context = explicit ?? this.getActiveContext();
+    return {
+      operationId: context?.operationId ?? this.operationId ?? getTelemetryOperationId(),
+      ...context !== undefined ? { parentId: context.id } : {}
+    };
+  }
+  spanFor(name, durationMs, success, properties, context) {
+    return {
+      name: redactSpanName(name),
+      durationMs,
+      success,
+      properties: this.enrichProperties(properties),
+      operationId: context.operationId,
+      ...context.parentId !== undefined ? { parentId: context.parentId } : {},
+      id: context.id,
+      ...context.startedAt !== undefined ? { startedAt: context.startedAt } : {}
+    };
+  }
+  enrichProperties(properties) {
     const globalProperties = getGlobalTelemetryProperties();
     const enriched = {
       ...getExecutionContextTelemetryProperties(),
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
-      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
-      ...context ? {
-        [TELEMETRY_OPERATION_ID_PROPERTY]: context.operationId,
-        ...context.parentId !== undefined ? { [TELEMETRY_PARENT_ID_PROPERTY]: context.parentId } : {},
-        [TELEMETRY_SPAN_ID_PROPERTY]: context.id
-      } : {}
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource()
     };
     return enriched;
   }
@@ -3382,6 +3957,81 @@ class TelemetryService {
     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;
+  }
+  getState().commandStart = performance.now();
+}
+function recordCommandDuration(durationMs) {
+  if (!timingsEnabled()) {
+    return;
+  }
+  getState().commandMs = durationMs;
+}
 // ../common/src/telemetry/proxy-http-agent.ts
 var slot = singleton("ProxyAuthHttpsAgent");
 
@@ -3402,6 +4052,9 @@ function getGlobalTelemetryInstance() {
   }
   return;
 }
+function setGlobalTelemetryInstance(instance) {
+  telemetryInstanceSlot.set(instance);
+}
 var _localTelemetryInstance;
 function getTelemetryInstance() {
   const global = getGlobalTelemetryInstance();
@@ -3409,6 +4062,7 @@ function getTelemetryInstance() {
     return global;
   if (!_localTelemetryInstance) {
     _localTelemetryInstance = new TelemetryService(new LoggerTelemetryProvider, new NodeContextStorage);
+    setGlobalTelemetryInstance(_localTelemetryInstance);
   }
   return _localTelemetryInstance;
 }
@@ -3421,6 +4075,14 @@ var telemetry = new Proxy({}, {
 });
 
 // ../common/src/formatter.ts
+var ANSI_STYLES = {
+  red: "\x1B[31m",
+  dim: "\x1B[2m"
+};
+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",
@@ -3492,23 +4154,6 @@ function derivePaginationHasMore(returned, limit, offset, total, nextPage) {
   }
   return (offset ?? 0) + returned < total;
 }
-
-class SuccessOutput {
-  Result = RESULTS.Success;
-  Code;
-  Data;
-  Pagination;
-  Instructions;
-  Log;
-  constructor(code, data) {
-    this.Code = code;
-    this.Data = data;
-    const logPath = getLogFilePath();
-    if (logPath) {
-      this.Log = logPath;
-    }
-  }
-}
 function escapeNonAscii(jsonText) {
   return jsonText.replace(/[\u0080-\uffff]/g, (c) => {
     const hex = c.charCodeAt(0).toString(16).padStart(4, "0");
@@ -3573,19 +4218,45 @@ function toPascalCaseKey(key) {
   const lowerCamelKey = toLowerCamelCaseKey(key);
   return lowerCamelKey ? lowerCamelKey.charAt(0).toUpperCase() + lowerCamelKey.slice(1) : lowerCamelKey;
 }
-function toPascalCaseData(value) {
+function collectVerbatimRefs(value, into) {
+  if (typeof value !== "object" || value === null)
+    return;
+  if (into.has(value))
+    return;
+  into.add(value);
+  for (const nested of Array.isArray(value) ? value : Object.values(value)) {
+    collectVerbatimRefs(nested, into);
+  }
+}
+function toPascalCaseData(value, verbatimKeys, subtrees) {
+  if (subtrees?.mode === "skip" && typeof value === "object" && value !== null && subtrees.refs.has(value)) {
+    return value;
+  }
   if (Array.isArray(value))
-    return value.map(toPascalCaseData);
+    return value.map((entry) => toPascalCaseData(entry, verbatimKeys, subtrees));
   if (!isPlainRecord(value))
     return value;
   const result = {};
   for (const [key, nestedValue] of Object.entries(value)) {
-    result[toPascalCaseKey(key)] = toPascalCaseData(nestedValue);
+    const pascalKey = toPascalCaseKey(key);
+    if (verbatimKeys?.has(pascalKey)) {
+      result[pascalKey] = nestedValue;
+      if (subtrees?.mode === "collect") {
+        collectVerbatimRefs(nestedValue, subtrees.refs);
+      }
+      continue;
+    }
+    result[pascalKey] = toPascalCaseData(nestedValue, verbatimKeys, subtrees);
   }
   return result;
 }
-function normalizeDataKeys(data) {
-  return toPascalCaseData(data);
+function normalizeDataKeys(data, verbatimKeys, subtrees) {
+  return toPascalCaseData(data, verbatimKeys, subtrees);
+}
+function toVerbatimKeySet(preserve) {
+  if (!Array.isArray(preserve))
+    return;
+  return new Set(preserve.map(toPascalCaseKey));
 }
 function normalizeOutputKeys(data) {
   const result = {};
@@ -3595,7 +4266,7 @@ function normalizeOutputKeys(data) {
   }
   return result;
 }
-function printOutput(data, format = "json", logFn, asciiSafe = false) {
+function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowStyle) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
@@ -3630,7 +4301,7 @@ function printOutput(data, format = "json", logFn, asciiSafe = false) {
       if (hasData && !(rows !== null && rows.length === 0)) {
         const logValue = data.Log;
         if (rows !== null) {
-          printResizableTable(rows, logFn, logValue);
+          printResizableTable(rows, logFn, logValue, undefined, tableRowStyle);
         } else {
           printVerticalTable(data.Data, logFn, logValue);
         }
@@ -3641,10 +4312,11 @@ function printOutput(data, format = "json", logFn, asciiSafe = false) {
     }
   }
 }
-function logOutput(data, format = "json") {
+function logOutput(data, format = "json", tableRowStyle) {
   const sink = getOutputSink();
+  const styleFn = sink.capabilities.isInteractive && sink.capabilities.supportsColor ? tableRowStyle : undefined;
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
-`), needsAsciiSafeJson(sink));
+`), needsAsciiSafeJson(sink), styleFn);
 }
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
@@ -3658,7 +4330,7 @@ function wrapText(text, width) {
   }
   return lines;
 }
-function printTable(data, logFn, externalLogValue) {
+function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
   const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
@@ -3668,7 +4340,7 @@ function printTable(data, logFn, externalLogValue) {
   logFn(keys.map((_, i) => "-".repeat(maxWidths[i])).join("-|-"));
   data.forEach((item) => {
     const row = keys.map((key, i) => cellToString(item[key]).padEnd(maxWidths[i])).join(" | ");
-    logFn(row);
+    logFn(styleLine(row, tableRowStyle?.(item)));
   });
   if (externalLogValue) {
     logFn("");
@@ -3711,14 +4383,14 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
     logFn(`Log: ${externalLogValue}`);
   }
 }
-function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth) {
+function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
   const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
-    printTable(data, logFn, externalLogValue);
+    printTable(data, logFn, externalLogValue, tableRowStyle);
     return;
   }
   const naturalWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
@@ -3726,7 +4398,7 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
   const totalWidth = naturalWidths.reduce((a, b) => a + b, 0) + separatorTotal;
   const termWidth = availableWidth ?? (process.stdout.columns || 120);
   if (totalWidth <= termWidth) {
-    printTable(data, logFn, externalLogValue);
+    printTable(data, logFn, externalLogValue, tableRowStyle);
     return;
   }
   const overflow = totalWidth - termWidth;
@@ -3772,6 +4444,7 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
   logFn(header);
   logFn(keys.map((_, i) => "-".repeat(finalWidths[i])).join("-|-"));
   data.forEach((item) => {
+    const style = tableRowStyle?.(item);
     const cellLines = keys.map((key, i) => wrapText(cellToString(item[key]), finalWidths[i]));
     const lineCount = Math.max(...cellLines.map((l) => l.length));
     for (let line = 0;line < lineCount; line++) {
@@ -3779,7 +4452,7 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
         const val = line < cellLines[i].length ? cellLines[i][line] : "";
         return val.padEnd(finalWidths[i]);
       }).join(" | ");
-      logFn(row);
+      logFn(styleLine(row, style));
     }
   });
   if (externalLogValue) {
@@ -3923,30 +4596,36 @@ var OutputFormatter;
 ((OutputFormatter) => {
   function success(data, options) {
     data.Log ??= getLogFilePath() || undefined;
-    const normalize = !options?.preserveDataKeys;
+    const normalize = options?.preserveDataKeys !== true;
+    const verbatim = toVerbatimKeySet(options?.preserveDataKeys);
+    const subtrees = verbatim && {
+      refs: new Set,
+      mode: "collect"
+    };
     if (normalize) {
-      data.Data = normalizeDataKeys(data.Data);
+      data.Data = normalizeDataKeys(data.Data, verbatim, subtrees);
     }
     const filter = getOutputFilter();
     if (filter) {
       const filtered = applyFilter(data.Data, filter);
-      data.Data = normalize ? normalizeDataKeys(filtered) : filtered;
+      data.Data = normalize ? normalizeDataKeys(filtered, verbatim, subtrees && { refs: subtrees.refs, mode: "skip" }) : filtered;
     }
-    logOutput(normalizeOutputKeys(data), getOutputFormat());
+    logOutput(normalizeOutputKeys(data), getOutputFormat(), options?.tableRowStyle);
   }
   OutputFormatter.success = success;
   function error(data) {
     data.Log ??= getLogFilePath() || undefined;
     data.ErrorCode ??= defaultErrorCodeForFailure(data);
     data.Retry ??= defaultRetryForErrorCode(data.ErrorCode);
-    process.exitCode = EXIT_CODES[data.Result] ?? 1;
+    const exitCode = EXIT_CODES[data.Result] ?? 1;
+    setExitCode(exitCode);
     recordCommandFailureTelemetry({
       result: data.Result,
       errorCode: data.ErrorCode,
       retry: data.Retry,
       message: data.Message,
       context: data.Context,
-      exitCode: process.exitCode,
+      exitCode,
       errorClass: data.TelemetryErrorClass,
       terminalOutcome: data.TelemetryTerminalOutcome,
       terminalSignal: data.TelemetryTerminalSignal
@@ -4022,6 +4701,39 @@ var OutputFormatter;
   }
   OutputFormatter.formatToString = formatToString;
 })(OutputFormatter ||= {});
+// ../../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/command-examples.ts
+var examplesByCommand = new WeakMap;
+Command.prototype.examples = function(examples) {
+  examplesByCommand.set(this, examples);
+  return this;
+};
+// ../common/src/preview.ts
+var previewSlot = singleton("PreviewBuild");
+function isPreviewBuild() {
+  return previewSlot.get(false) ?? false;
+}
+Command.prototype.previewCommand = function(nameAndArgs, opts) {
+  if (isPreviewBuild()) {
+    return this.command(nameAndArgs, opts);
+  }
+  return new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
+};
 
 // ../common/src/telemetry/command-attribution.ts
 var LEGACY_SKILL_NAMESPACE = "uipath:";
@@ -4176,6 +4888,57 @@ function buildCommandTelemetryAttribution(commandPath, skillSource) {
   };
 }
 
+// ../common/src/telemetry/command-name.ts
+var TELEMETRY_COMMAND_ROOT = "uip";
+function commandTelemetryName(parts) {
+  const tokens = [];
+  for (const part of parts) {
+    const pieces = String(part ?? "").split(/\s+/).filter((token) => token && !token.startsWith("-") && token !== TELEMETRY_COMMAND_ROOT);
+    if (pieces.every(isCommandToken)) {
+      tokens.push(...pieces);
+      continue;
+    }
+    tokens.push(UNKNOWN_TOKEN);
+  }
+  return [TELEMETRY_COMMAND_ROOT, ...tokens].join(".");
+}
+var COMMAND_TOKEN_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var MAX_COMMAND_TOKEN_LENGTH = 32;
+var GUID_TOKEN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function isCommandToken(token) {
+  return token.length <= MAX_COMMAND_TOKEN_LENGTH && COMMAND_TOKEN_PATTERN.test(token) && !GUID_TOKEN.test(token) && !/^\d+$/.test(token);
+}
+var UNKNOWN_TOKEN = "<unknown>";
+
+// ../common/src/telemetry/invocation-request.ts
+var requestContextSlot = singleton("TelemetryInvocationRequestContext");
+function activeContext() {
+  return telemetry.getActiveContext?.();
+}
+function runWithInvocationRequest(fn) {
+  const context = telemetry.createRequestContext();
+  context.startedAt = invocationStartedAt();
+  requestContextSlot.set(context);
+  return telemetry.runWithContext(context, fn);
+}
+function ensureInvocationRequestScope(fn) {
+  if (activeContext() !== undefined) {
+    return fn();
+  }
+  const kept = requestContextSlot.get();
+  return kept === undefined ? runWithInvocationRequest(fn) : telemetry.runWithContext(kept, fn);
+}
+function getInvocationRequestContext() {
+  return activeContext() ?? requestContextSlot.get();
+}
+function emitInvocationRequest(name, success, properties) {
+  const context = getInvocationRequestContext();
+  telemetry.trackRequestResult(name, invocationElapsedMs(), success, properties, context);
+  if (context !== undefined && requestContextSlot.get() === context) {
+    requestContextSlot.clear();
+  }
+}
+
 // ../common/src/trackedAction.ts
 var pollSignalSlot = singleton("PollSignal");
 var cliErrorCodeValues = new Set(CLI_ERROR_CODES);
@@ -4183,28 +4946,74 @@ var retryHintValues = new Set(RETRY_HINTS);
 var TELEMETRY_COMMAND_ARG_PREFIX = "uip.cmd.arg.";
 var processContext = {
   exit: (code) => {
-    process.exitCode = code;
+    recordExitCode(code);
+    setExitCode(code);
   },
   get pollSignal() {
     return pollSignalSlot.get();
   }
 };
+var TELEMETRY_ARG_VALUE_WITHHELD = "<provided>";
+var TELEMETRY_ARG_VALUE_DEFAULTED = "<default>";
+function recordableArgValue(value, choices) {
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (choices && choices.length > 0) {
+    if (typeof value === "string" && choices.includes(value)) {
+      return value;
+    }
+    if (Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && choices.includes(entry))) {
+      return value.join(",");
+    }
+  }
+  return TELEMETRY_ARG_VALUE_WITHHELD;
+}
 function extractCommandParams(cmd) {
   const params = {};
-  const add = (name, value) => {
-    if (name && value !== undefined) {
-      params[`${TELEMETRY_COMMAND_ARG_PREFIX}${name}`] = value;
-    }
-  };
+  forEachSuppliedArgument(cmd, (name, value, choices, defaulted) => {
+    const recordable = recordableArgValue(value, choices);
+    params[`${TELEMETRY_COMMAND_ARG_PREFIX}${name}`] = recordable === TELEMETRY_ARG_VALUE_WITHHELD && defaulted ? TELEMETRY_ARG_VALUE_DEFAULTED : recordable;
+  });
+  return params;
+}
+function isDefaultedOption(cmd, name) {
+  const source = cmd.getOptionValueSource?.(name);
+  return source === "default" || source === "implied";
+}
+function isDefaultedPositional(cmd, index) {
+  return index >= (cmd.args?.length ?? 0);
+}
+function forEachSuppliedArgument(cmd, visit) {
   const registered = cmd.registeredArguments ?? [];
   const processed = cmd.processedArgs ?? [];
   for (let i = 0;i < registered.length; i++) {
-    add(registered[i].name(), processed[i]);
+    const name = registered[i].name();
+    if (name && processed[i] !== undefined) {
+      visit(name, processed[i], registered[i].argChoices, isDefaultedPositional(cmd, i));
+    }
+  }
+  const choicesByAttribute = new Map;
+  for (const option of cmd.options) {
+    choicesByAttribute.set(option.attributeName(), option.argChoices);
   }
   for (const [key, value] of Object.entries(cmd.opts())) {
-    add(key, value);
+    if (key && value !== undefined) {
+      visit(key, value, choicesByAttribute.get(key), isDefaultedOption(cmd, key));
+    }
   }
-  return params;
+}
+function withheldArgumentValues(cmd) {
+  const values = [];
+  forEachSuppliedArgument(cmd, (_name, value, choices, defaulted) => {
+    if (defaulted) {
+      return;
+    }
+    if (recordableArgValue(value, choices) === TELEMETRY_ARG_VALUE_WITHHELD) {
+      values.push(value);
+    }
+  });
+  return values;
 }
 function deriveCommandPath(cmd) {
   const parts = [];
@@ -4219,7 +5028,7 @@ function deriveCommandPath(cmd) {
   if (parts.length > 1) {
     parts.shift();
   }
-  return ["uip", ...parts.filter((p) => p !== "uip")].join(".");
+  return commandTelemetryName(parts);
 }
 function isCliErrorCode(value) {
   return typeof value === "string" && cliErrorCodeValues.has(value);
@@ -4259,68 +5068,77 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     });
     const telemetryName = deriveCommandPath(command);
     const props = typeof properties === "function" ? properties(...args) : properties;
-    const requestContext = telemetry.createRequestContext();
-    const startTime = performance.now();
-    let errorMessage;
-    let fallbackExitCode = EXIT_CODES.Success;
-    clearRecordedCommandFailureTelemetry();
-    const [error] = await catchError2(telemetry.runWithContext(requestContext, () => {
-      const violation = implicitLimitViolation(command);
-      if (violation) {
-        return Promise.reject(violation);
-      }
-      return fn(...args);
-    }));
-    if (error) {
-      errorMessage = error instanceof Error ? error.message : String(error);
-      logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
-      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 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];
-      OutputFormatter.error({
-        Result: finalResult,
-        ...customErrorCode ? { ErrorCode: customErrorCode } : {},
-        Message: errorMessage,
-        Instructions: customInstructions ?? commandHelpHint(telemetryName),
-        ...customRetry ? { Retry: customRetry } : {},
-        ...customContext ? { Context: customContext } : {}
+    markCommandStart();
+    const supplied = recordSuppliedArgumentValues(withheldArgumentValues(command));
+    try {
+      const startTime = performance.now();
+      let errorMessage;
+      let fallbackExitCode = EXIT_CODES.Success;
+      clearRecordedCommandFailureTelemetry();
+      const [error] = await catchError(ensureInvocationRequestScope(() => {
+        const violation = implicitLimitViolation(command);
+        if (violation) {
+          return Promise.reject(violation);
+        }
+        return fn(...args);
+      }));
+      if (error) {
+        errorMessage = error instanceof Error ? error.message : String(error);
+        logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
+        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 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];
+        OutputFormatter.error({
+          Result: finalResult,
+          ...customErrorCode ? { ErrorCode: customErrorCode } : {},
+          Message: errorMessage,
+          Instructions: customInstructions ?? commandHelpHint(telemetryName),
+          ...customRetry ? { Retry: customRetry } : {},
+          ...customContext ? { Context: customContext } : {}
+        });
+        context.exit(fallbackExitCode);
+      }
+      const durationMs = performance.now() - startTime;
+      recordCommandDuration(durationMs);
+      const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
+      const recordedFailure = takeRecordedCommandFailureTelemetry();
+      const success = !error && exitCode === 0;
+      const terminalTelemetry = buildCommandTerminalTelemetryProperties({
+        error,
+        exitCode,
+        recordedFailure,
+        pollSignal: context.pollSignal
       });
-      context.exit(fallbackExitCode);
-    }
-    const durationMs = performance.now() - startTime;
-    const exitCode = fallbackExitCode === 130 ? fallbackExitCode : exitCodeFromProcess(fallbackExitCode);
-    const recordedFailure = takeRecordedCommandFailureTelemetry();
-    const success = !error && exitCode === 0;
-    const terminalTelemetry = buildCommandTerminalTelemetryProperties({
-      error,
-      exitCode,
-      recordedFailure,
-      pollSignal: context.pollSignal
-    });
-    const commandParams = extractCommandParams(command);
-    if (props) {
-      for (const key of Object.keys(props)) {
-        delete commandParams[`${TELEMETRY_COMMAND_ARG_PREFIX}${key}`];
-      }
-    }
-    const baseProperties = redactProperties({
-      ...commandParams,
-      ...props,
-      ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
-      command: "true",
-      ...terminalTelemetry,
-      ...errorMessage ? { errorMessage } : {}
-    });
-    telemetry.trackRequestResult(telemetryName, durationMs, success, baseProperties, requestContext);
+      if (terminalTelemetry.error_class === "internal" && error) {
+        telemetry.trackException(error instanceof Error ? error : new Error(String(error)), { command_name: telemetryName }, getInvocationRequestContext());
+      }
+      const commandParams = extractCommandParams(command);
+      if (props) {
+        for (const key of Object.keys(props)) {
+          delete commandParams[`${TELEMETRY_COMMAND_ARG_PREFIX}${key}`];
+        }
+      }
+      const baseProperties = redactProperties({
+        ...commandParams,
+        ...props,
+        ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
+        command: "true",
+        ...terminalTelemetry,
+        ...errorMessage ? { errorMessage } : {}
+      });
+      emitInvocationRequest(telemetryName, success, baseProperties);
+    } finally {
+      releaseSuppliedArgumentValues(supplied);
+    }
   });
 };
 // ../common/src/completer.ts
@@ -4330,6 +5148,204 @@ var guardInstalledSlot = singleton("ConsoleGuardInstalled");
 var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 // ../common/src/constants.ts
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+// ../common/src/entity-name-rules.ts
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
 // ../common/src/host-global-options.ts
 var HOST_GLOBAL_OPTIONS_WITH_VALUE = [
   "--output",
@@ -4497,7 +5513,7 @@ class InsightsProtocolError extends Error {
 var package_default2 = {
   name: "@uipath/insights-sdk",
   license: "MIT",
-  version: "1.201.0",
+  version: "1.202.0-preview.136",
   description: "SDK for the UiPath Insights API — jobs, failures, and performance metrics.",
   repository: {
     type: "git",
@@ -4716,7 +5732,7 @@ function classifyErrorBody(text) {
   if (head.startsWith("<!doctype") || head.startsWith("<html")) {
     return "html";
   }
-  const [parseError] = catchError2(() => JSON.parse(text));
+  const [parseError] = catchError(() => JSON.parse(text));
   if (!parseError) {
     return "json";
   }
@@ -4745,10 +5761,10 @@ async function requestInsightsRoute(config, routeKey, request = {}) {
   if (!route) {
     throw new Error(`Unsupported Insights route "${routeKey}".`);
   }
-  const path = buildRoutePath(routeKey, route.template, config, request.pathParams ?? {});
-  const url = `${config.baseUrl}/${encodePathSegment(routeKey, "organizationId", config.organizationId)}/${encodePathSegment(routeKey, "tenantName", config.tenantName)}/${SERVICE_ROOTS[route.service]}/${path}`;
+  const path2 = buildRoutePath(routeKey, route.template, config, request.pathParams ?? {});
+  const url = `${config.baseUrl}/${encodePathSegment(routeKey, "organizationId", config.organizationId)}/${encodePathSegment(routeKey, "tenantName", config.tenantName)}/${SERVICE_ROOTS[route.service]}/${path2}`;
   const hasBody = request.body !== undefined;
-  const [fetchError, response] = await catchError2(fetch(url, {
+  const [fetchError, response] = await catchError(fetch(url, {
     method: route.method,
     headers: buildServiceHeaders(config, route.service, hasBody),
     body: hasBody ? JSON.stringify(request.body) : undefined
@@ -4756,7 +5772,7 @@ async function requestInsightsRoute(config, routeKey, request = {}) {
   if (fetchError) {
     throw new InsightsNetworkError(route.template, fetchError);
   }
-  const [readError, text] = await catchError2(response.text());
+  const [readError, text] = await catchError(response.text());
   if (readError) {
     if (!response.ok) {
       throw httpErrorFrom(response, route, "absent", readError);
@@ -4772,7 +5788,7 @@ async function requestInsightsRoute(config, routeKey, request = {}) {
     }
     throw new InsightsProtocolError(route.template, "empty response body");
   }
-  const [parseError, parsed] = catchError2(() => JSON.parse(text));
+  const [parseError, parsed] = catchError(() => JSON.parse(text));
   if (parseError) {
     throw new InsightsProtocolError(route.template, "response body is not valid JSON");
   }
@@ -4798,9 +5814,28 @@ async function getAlertDefinition(config, alertDefinitionId) {
 async function checkAlertEntitlement(config) {
   return requestInsightsRoute(config, "alertDefinitionsCheckEntitlement");
 }
+function withSessionTenantId(config, request) {
+  const base = typeof request === "object" && request !== null && !Array.isArray(request) ? request : {};
+  return { ...base, tenantId: config.tenantId };
+}
+async function listAlertHistoryDetails(config, request) {
+  return requestInsightsRoute(config, "alertHistoryDetails", {
+    body: withSessionTenantId(config, request)
+  });
+}
+async function getAlertHistoryMetrics(config, request) {
+  return requestInsightsRoute(config, "alertHistoryMetrics", {
+    body: withSessionTenantId(config, request)
+  });
+}
+async function getDefaultDelivery(config, alertDeliveryId) {
+  return requestInsightsRoute(config, "defaultDeliveryGet", {
+    pathParams: { alertDeliveryId }
+  });
+}
 // ../insights-sdk/src/client.ts
-function buildInsightsUrl(config, path) {
-  return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/insightsrtm_/api/v1.0/InsightsJobs${path}`;
+function buildInsightsUrl(config, path2) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/insightsrtm_/api/v1.0/InsightsJobs${path2}`;
 }
 function buildHeaders(config) {
   return {
@@ -4811,8 +5846,8 @@ function buildHeaders(config) {
     "X-UiPath-Internal-TenantName": config.tenantName
   };
 }
-async function insightsPost(config, path, body) {
-  const url = buildInsightsUrl(config, path);
+async function insightsPost(config, path2, body) {
+  const url = buildInsightsUrl(config, path2);
   const headers = buildHeaders(config);
   const response = await fetch(url, {
     method: "POST",
@@ -4826,12 +5861,46 @@ async function insightsPost(config, path, body) {
   const text = await response.text();
   if (!text)
     throw new Error("API returned an empty response body");
-  const [parseErr, parsed] = catchError2(() => JSON.parse(text));
+  const [parseErr, parsed] = catchError(() => JSON.parse(text));
   if (parseErr) {
     throw new Error(`Failed to parse API response body: ${parseErr.message}`);
   }
   return parsed;
 }
+// ../auth/src/catch-error.ts
+function isPromiseLike2(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError2(fnOrPromise) {
+  if (isPromiseLike2(fnOrPromise)) {
+    return settlePromiseLike2(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike2(result)) {
+      return settlePromiseLike2(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [
+      error instanceof Error ? error : new Error(String(error)),
+      undefined
+    ];
+  }
+}
+function settlePromiseLike2(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+
+// ../auth/src/constants.ts
+var UIPATH_HOME_DIR = ".uipath";
+var AUTH_FILENAME = ".auth";
+var DEFAULT_BASE_URL = "https://cloud.uipath.com";
+var DEFAULT_AUTH_TIMEOUT_MS2 = 5 * 60 * 1000;
+
 // ../auth/src/config.ts
 var DEFAULT_CLIENT_ID = "36dea5b8-e8bb-423d-8e7b-c808df8f1c00";
 var AUTH_FILE_CONFIG_KEY = Symbol.for("@uipath/auth/AuthFileConfig");
@@ -4845,7 +5914,7 @@ class InvalidBaseUrlError extends Error {
     super(`Invalid base URL: "${url}"
 ` + `Reason: ${reason}
 
-` + `Expected format: an https:// URL, e.g. https://cloud.uipath.com (commercial), https://govcloud.uipath.us (Public Sector), or your Automation Suite host (https://<your-host>).
+` + `Expected format: an https:// URL (or bare host — https:// is assumed), e.g. https://cloud.uipath.com (commercial), https://govcloud.uipath.us (Public Sector), or your Automation Suite host (https://<your-host>).
 ` + `You can specify the URL via:
 ` + `  • --authority flag
 ` + `  • UIPATH_URL environment variable
@@ -4866,10 +5935,16 @@ var normalizeAndValidateBaseUrl = (rawUrl) => {
   while (baseUrl.endsWith("/")) {
     baseUrl = baseUrl.slice(0, -1);
   }
+  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseUrl);
+  const [hostCandidate] = baseUrl.split(/[/?#]/, 1);
+  if (!hasScheme && hostCandidate.includes(".")) {
+    baseUrl = `https://${baseUrl}`;
+  }
   const resolvedBaseUrl = baseUrl;
-  const [urlError, url] = catchError(() => new URL(resolvedBaseUrl));
+  const [urlError, url] = catchError2(() => new URL(resolvedBaseUrl));
   if (urlError) {
-    throw new InvalidBaseUrlError(baseUrl, `Malformed URL. ${urlError instanceof Error ? urlError.message : "Unknown error"}`);
+    const shapeHint = !hasScheme && !hostCandidate.includes(".") ? ` "${rawUrl.trim()}" is not a URL or a host name. Pass the full authority URL — https://<host>, or just <host> (https:// is assumed).` : ` ${urlError instanceof Error ? urlError.message : "Unknown error"}`;
+    throw new InvalidBaseUrlError(baseUrl, `Malformed URL.${shapeHint}`);
   }
   if (url.protocol !== "https:") {
     throw new InvalidBaseUrlError(baseUrl, `Authority must use https:// scheme, got ${url.protocol}//. OIDC token exchange requires TLS end-to-end.`);
@@ -4924,6 +5999,11 @@ var resolveConfigAsync = async ({
   };
 };
 
+// ../auth/src/utils/platform.ts
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && "document" in globalThis;
+}
+
 // ../auth/src/authProfile.ts
 var DEFAULT_AUTH_PROFILE = "default";
 var PROFILE_DIR = "profiles";
@@ -4935,7 +6015,7 @@ function isAuthProfileStorage(value) {
   return value !== null && typeof value === "object" && "getStore" in value && "run" in value;
 }
 function createProfileStorage() {
-  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  const [error, mod] = catchError2(() => __require("node:async_hooks"));
   if (error || typeof mod?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
@@ -4951,9 +6031,9 @@ function getProfileStorage() {
   if (isAuthProfileStorage(existing)) {
     return existing;
   }
-  const storage = createProfileStorage();
-  globalSlot2[AUTH_PROFILE_STORAGE_KEY] = storage;
-  return storage;
+  const storage2 = createProfileStorage();
+  globalSlot2[AUTH_PROFILE_STORAGE_KEY] = storage2;
+  return storage2;
 }
 var profileStorage = getProfileStorage();
 
@@ -4984,8 +6064,8 @@ function resolveAuthProfileFilePath(profile) {
   if (normalized === undefined) {
     throw new AuthProfileValidationError(`"${DEFAULT_AUTH_PROFILE}" is the built-in profile and does not have a profile file path.`);
   }
-  const fs = getFileSystem();
-  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
+  const fs2 = getFileSystem();
+  return fs2.path.join(fs2.env.homedir(), UIPATH_HOME_DIR, PROFILE_DIR, normalized, AUTH_FILENAME);
 }
 function getActiveAuthProfileFilePath() {
   const profile = getActiveAuthProfile();
@@ -5066,7 +6146,7 @@ var getTokenExpiration = (accessToken) => {
 // ../auth/src/sessionIdentity.ts
 var parseAuthFlow = (value) => value === "authorization_code" || value === "client_credentials" || value === "federated_credentials" ? value : undefined;
 var decodeClaims = (accessToken) => {
-  const [error, claims] = catchError(() => parseJWT(accessToken));
+  const [error, claims] = catchError2(() => parseJWT(accessToken));
   return error ? undefined : claims;
 };
 var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
@@ -5150,27 +6230,48 @@ var requireEnv = (name) => {
   }
   return value;
 };
+var OPAQUE_TOKEN_BASE_URL_VAR = "UIPATH_URL";
+var resolveBaseUrl = (rawUrl, failureContext) => {
+  const [baseUrlError, baseUrl] = catchError2(() => normalizeAndValidateBaseUrl(rawUrl));
+  if (baseUrlError) {
+    if (baseUrlError instanceof InvalidBaseUrlError) {
+      throw baseUrlError;
+    }
+    throw new EnvAuthConfigError(`${failureContext}: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
+  }
+  return baseUrl;
+};
 var readAuthFromEnv = () => {
   const accessToken = requireEnv(ENV_AUTH_VARS.token);
   const organizationName = requireEnv(ENV_AUTH_VARS.organizationName);
   const organizationId = requireEnv(ENV_AUTH_VARS.organizationId);
   const tenantName = requireEnv(ENV_AUTH_VARS.tenantName);
   const tenantId = requireEnv(ENV_AUTH_VARS.tenantId);
-  const [parseError, payload] = catchError(() => parseJWT(accessToken));
+  const [parseError, payload] = catchError2(() => parseJWT(accessToken));
   if (parseError) {
-    throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a valid JWT: ` + `${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    const parseErrorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+    const rawUrl = process.env[OPAQUE_TOKEN_BASE_URL_VAR];
+    if (!rawUrl) {
+      throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a JWT (treating it as an opaque token, ` + `e.g. a Personal Access Token). Set ${OPAQUE_TOKEN_BASE_URL_VAR} to the ` + `UiPath base URL if this is a PAT, or fix the token if it was meant to ` + `be a JWT (parse error: ${parseErrorMessage}).`);
+    }
+    const baseUrl2 = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
+    return {
+      loginStatus: "Logged in",
+      accessToken,
+      baseUrl: baseUrl2,
+      organizationName,
+      organizationId,
+      tenantName,
+      tenantId,
+      source: "env-vars" /* EnvironmentVariables */,
+      hint: "Token is opaque (not a JWT) - expiration and identity cannot be " + "determined locally. Commands will fail with 401 once it is revoked or " + `expired. If this was meant to be a JWT instead of a PAT, note: ${parseErrorMessage}`
+    };
   }
   const iss = payload.iss;
   if (typeof iss !== "string" || iss.length === 0) {
     throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} has no 'iss' claim; cannot determine ` + `the UiPath server. Ensure the token was issued by a UiPath identity server.`);
   }
-  const [baseUrlError, baseUrl] = catchError(() => normalizeAndValidateBaseUrl(iss));
-  if (baseUrlError) {
-    if (baseUrlError instanceof InvalidBaseUrlError) {
-      throw baseUrlError;
-    }
-    throw new EnvAuthConfigError(`Failed to derive server URL from token 'iss' claim: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
-  }
+  const baseUrl = resolveBaseUrl(iss, "Failed to derive server URL from token 'iss' claim");
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
   const identity = resolveSessionIdentity(accessToken);
@@ -5196,8 +6297,8 @@ var SURFACE_WINDOW_MS = 60 * 60 * 1000;
 async function refreshTokenFingerprint(refreshToken) {
   const bytes = new TextEncoder().encode(refreshToken);
   if (globalThis.crypto?.subtle) {
-    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
+    const digest2 = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest2), (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
   }
   const { createHash } = await import("node:crypto");
   return createHash("sha256").update(refreshToken).digest("hex").slice(0, 16);
@@ -5206,9 +6307,9 @@ function breakerPathFor(authPath) {
   return `${authPath}${BREAKER_SUFFIX}`;
 }
 async function loadRefreshBreaker(authPath) {
-  const fs = getFileSystem();
+  const fs2 = getFileSystem();
   try {
-    const content = await fs.readFile(breakerPathFor(authPath), "utf-8");
+    const content = await fs2.readFile(breakerPathFor(authPath), "utf-8");
     if (!content)
       return {};
     const parsed = JSON.parse(content);
@@ -5219,20 +6320,20 @@ async function loadRefreshBreaker(authPath) {
 }
 async function saveRefreshBreaker(authPath, state) {
   try {
-    const fs = getFileSystem();
-    const path = breakerPathFor(authPath);
-    await fs.mkdir(fs.path.dirname(path));
-    const tempPath = `${path}.tmp`;
-    await fs.writeFile(tempPath, JSON.stringify(state));
-    await fs.rename(tempPath, path);
+    const fs2 = getFileSystem();
+    const path2 = breakerPathFor(authPath);
+    await fs2.mkdir(fs2.path.dirname(path2));
+    const tempPath = `${path2}.tmp`;
+    await fs2.writeFile(tempPath, JSON.stringify(state));
+    await fs2.rename(tempPath, path2);
   } catch {}
 }
 async function clearRefreshBreaker(authPath) {
-  const fs = getFileSystem();
-  const path = breakerPathFor(authPath);
+  const fs2 = getFileSystem();
+  const path2 = breakerPathFor(authPath);
   try {
-    if (await fs.exists(path)) {
-      await fs.rm(path);
+    if (await fs2.exists(path2)) {
+      await fs2.rm(path2);
     }
   } catch {}
 }
@@ -5253,43 +6354,43 @@ var ROBOT_USER_SERVICES_PIPE = "UiPathUserServices";
 var ROBOT_USER_SERVICES_ALTERNATE_PIPE = `${ROBOT_USER_SERVICES_PIPE}Alternate`;
 var PIPE_NAME_MAX_LENGTH = 103;
 var getRobotIpcPipeNames = async () => {
-  const fs = getFileSystem();
-  const username = fs.env.getenv("USER") ?? fs.env.getenv("USERNAME");
+  const fs2 = getFileSystem();
+  const username = fs2.env.getenv("USER") ?? fs2.env.getenv("USERNAME");
   if (!username) {
     throw new Error("Unable to determine current username");
   }
-  const tempPath = fs.env.getenv("TMPDIR") ?? "/tmp/";
-  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
+  const tempPath = fs2.env.getenv("TMPDIR") ?? "/tmp/";
+  return [ROBOT_USER_SERVICES_PIPE, ROBOT_USER_SERVICES_ALTERNATE_PIPE].map((baseName) => fs2.path.join(tempPath, `${baseName}_${username}`).substring(0, PIPE_NAME_MAX_LENGTH));
 };
 var defaultIsRobotIpcAvailable = async () => {
   if (process.platform === "win32") {
     return true;
   }
-  const [pipeNamesError, pipeNames] = await catchError(getRobotIpcPipeNames());
+  const [pipeNamesError, pipeNames] = await catchError2(getRobotIpcPipeNames());
   if (pipeNamesError || !pipeNames) {
     return false;
   }
-  const fs = getFileSystem();
+  const fs2 = getFileSystem();
   for (const pipeName of pipeNames) {
-    const [existsError, exists] = await catchError(fs.exists(pipeName));
+    const [existsError, exists] = await catchError2(fs2.exists(pipeName));
     if (!existsError && exists === true) {
       return true;
     }
   }
   return false;
 };
-var withTimeout = (promise, timeoutMs) => new Promise((resolve, reject) => {
+var withTimeout = (promise, timeoutMs) => new Promise((resolve2, reject) => {
   const timer = setTimeout(() => reject(new Error(`Robot IPC call timed out after ${timeoutMs}ms`)), timeoutMs);
   promise.then((value) => {
     clearTimeout(timer);
-    resolve(value);
+    resolve2(value);
   }, (error) => {
     clearTimeout(timer);
     reject(error);
   });
 });
 var parseResourceUrl = (url) => {
-  const [error, parsed] = catchError(() => new URL(url));
+  const [error, parsed] = catchError2(() => new URL(url));
   if (error || !parsed)
     return;
   const segments = parsed.pathname.split("/").filter(Boolean);
@@ -5309,7 +6410,7 @@ var defaultLoadModule = async () => {
   if (!hostLoader) {
     return;
   }
-  const [error, mod] = await catchError(() => hostLoader());
+  const [error, mod] = await catchError2(() => hostLoader());
   if (error || !mod) {
     return;
   }
@@ -5335,7 +6436,7 @@ var tryRobotClientFallback = async (options = {}) => {
   const mod = await loadModule();
   if (!mod)
     return;
-  const [ctorError, proxy] = catchError(() => new mod.RobotProxyConstructor);
+  const [ctorError, proxy] = catchError2(() => new mod.RobotProxyConstructor);
   if (ctorError || !proxy) {
     return;
   }
@@ -5358,7 +6459,7 @@ var tryRobotClientFallback = async (options = {}) => {
     let organizationIdFromToken;
     let tenantIdFromToken;
     let issuerFromToken;
-    const [jwtError, claims] = catchError(() => parseJWT(accessToken));
+    const [jwtError, claims] = catchError2(() => parseJWT(accessToken));
     if (!jwtError && claims) {
       const rawOrgId = claims.prtId ?? claims.organizationId ?? claims.prt_id;
       if (typeof rawOrgId === "string" && rawOrgId.length > 0) {
@@ -5385,7 +6486,7 @@ var tryRobotClientFallback = async (options = {}) => {
   } catch {
     return;
   } finally {
-    await catchError(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
+    await catchError2(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
   }
 };
 
@@ -5455,9 +6556,9 @@ var errorCode = (err) => {
   }
   return "EUNKNOWN";
 };
-var probeAsync = async (fs, candidate) => {
+var probeAsync = async (fs2, candidate) => {
   try {
-    const stats = await fs.stat(candidate);
+    const stats = await fs2.stat(candidate);
     if (stats === null) {
       return { exists: false };
     }
@@ -5484,9 +6585,9 @@ var probeAsync = async (fs, candidate) => {
   }
 };
 var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) => {
-  const fs = getFileSystem();
-  if (fs.path.isAbsolute(envFilePath)) {
-    const probe2 = await probeAsync(fs, envFilePath);
+  const fs2 = getFileSystem();
+  if (fs2.path.isAbsolute(envFilePath)) {
+    const probe2 = await probeAsync(fs2, envFilePath);
     return probe2.exists ? { exists: true, absolutePath: envFilePath, source: "absolute" } : {
       exists: false,
       absolutePath: envFilePath,
@@ -5494,11 +6595,11 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opt
       ...probe2.unusable ? { unusable: probe2.unusable } : {}
     };
   }
-  const cwd = opts?.cwd ?? fs.env.cwd();
+  const cwd = opts?.cwd ?? fs2.env.cwd();
   let searchDir = cwd;
   while (true) {
-    const candidate = fs.path.join(searchDir, envFilePath);
-    const probe2 = await probeAsync(fs, candidate);
+    const candidate = fs2.path.join(searchDir, envFilePath);
+    const probe2 = await probeAsync(fs2, candidate);
     if (probe2.exists) {
       return {
         exists: true,
@@ -5506,14 +6607,14 @@ var resolveEnvFileLocationAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opt
         source: searchDir === cwd ? "cwd" : "ancestor"
       };
     }
-    const parentDir = fs.path.dirname(searchDir);
+    const parentDir = fs2.path.dirname(searchDir);
     if (parentDir === searchDir) {
       break;
     }
     searchDir = parentDir;
   }
-  const homePath = fs.path.join(fs.env.homedir(), envFilePath);
-  const probe = await probeAsync(fs, homePath);
+  const homePath = fs2.path.join(fs2.env.homedir(), envFilePath);
+  const probe = await probeAsync(fs2, homePath);
   if (probe.exists) {
     return { exists: true, absolutePath: homePath, source: "home" };
   }
@@ -5535,12 +6636,12 @@ var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) =
   };
 };
 var loadEnvFileAsync = async ({ envPath }) => {
-  const fs = getFileSystem();
-  const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.cwd(), envPath);
-  if (!await fs.exists(absolutePath)) {
+  const fs2 = getFileSystem();
+  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.cwd(), envPath);
+  if (!await fs2.exists(absolutePath)) {
     throw new Error(`Environment file not found: ${envPath}`);
   }
-  const content = await fs.readFile(absolutePath, "utf-8");
+  const content = await fs2.readFile(absolutePath, "utf-8");
   if (content === null) {
     throw new Error(`Environment file not found: ${envPath}`);
   }
@@ -5569,10 +6670,10 @@ var saveEnvFileAsync = async ({
   data,
   merge = true
 }) => {
-  const fs = getFileSystem();
-  const absolutePath = fs.path.isAbsolute(envPath) ? envPath : fs.path.join(fs.env.homedir(), envPath);
+  const fs2 = getFileSystem();
+  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.homedir(), envPath);
   let existingData = {};
-  if (merge && await fs.exists(absolutePath)) {
+  if (merge && await fs2.exists(absolutePath)) {
     try {
       existingData = await loadEnvFileAsync({ envPath: absolutePath });
     } catch {}
@@ -5590,11 +6691,11 @@ var saveEnvFileAsync = async ({
   const content = `${lines.join(`
 `)}
 `;
-  const dir = fs.path.dirname(absolutePath);
-  await fs.mkdir(dir);
+  const dir = fs2.path.dirname(absolutePath);
+  await fs2.mkdir(dir);
   const tempPath = `${absolutePath}.tmp`;
-  await fs.writeFile(tempPath, content);
-  await fs.rename(tempPath, absolutePath);
+  await fs2.writeFile(tempPath, content);
+  await fs2.rename(tempPath, absolutePath);
 };
 
 // ../auth/src/loginStatus.ts
@@ -5708,11 +6809,11 @@ async function loadFileCredentials(loadEnvFile, absolutePath) {
   return { credentials };
 }
 async function getGlobalCredsHint(getFs, loadEnvFile, absolutePath, envFilePath) {
-  const fs = getFs();
-  const globalPath = fs.path.join(fs.env.homedir(), envFilePath);
+  const fs2 = getFs();
+  const globalPath = fs2.path.join(fs2.env.homedir(), envFilePath);
   if (absolutePath === globalPath)
     return;
-  if (!await fs.exists(globalPath))
+  if (!await fs2.exists(globalPath))
     return;
   try {
     const globalCreds = await loadEnvFile({ envPath: globalPath });
@@ -6200,6 +7301,10 @@ async function listQueueFilters(config) {
 async function listMachineFilters(config) {
   return listFilters(config, "filtersAllMachines", isMachineFiltersResponse, "machine filters");
 }
+// ../insights-sdk/src/rbac.ts
+async function listUsers(config) {
+  return requestInsightsRoute(config, "usersList");
+}
 // src/utils/output.ts
 function fail(message, instructions) {
   OutputFormatter.error({
@@ -6250,7 +7355,7 @@ function writeConfigError(error) {
   processContext.exit(EXIT_CODES.AuthenticationError);
 }
 async function resolveInsightsConfig() {
-  const [configError, config] = await catchError2(createInsightsConfig());
+  const [configError, config] = await catchError(createInsightsConfig());
   if (configError) {
     writeConfigError(configError);
     return null;
@@ -6288,6 +7393,33 @@ function writeInsightsNotFound(error, message, instructions) {
   });
   processContext.exit(EXIT_CODES.Failure);
 }
+function surfaceUnavailableInstructions(family) {
+  return [
+    `The real-time APIs behind 'uip insights' are not enabled on every deployment: Automation Suite and Service Fabric serve only a converted subset, and the ${family.subject} routes are not in it.`,
+    "This is not a statement about the tenant's data or your permissions, and neither logging in again nor retrying changes it.",
+    "Run these commands against a cloud deployment instead."
+  ].join(" ");
+}
+function writeInsightsSurfaceUnavailable(error, family) {
+  OutputFormatter.error({
+    Result: RESULTS.ConfigError,
+    ErrorCode: "configuration_error",
+    Retry: "RetryWillNotFix",
+    Message: `The Insights real-time API did not serve the ${family.subject} routes on this deployment. These routes are feature-gated to Cloud and Dedicated SaaS.`,
+    Instructions: surfaceUnavailableInstructions(family),
+    Context: httpErrorContext(error)
+  });
+  processContext.exit(EXIT_CODES.ConfigError);
+}
+function claimGatedSurface404(family) {
+  return (error) => {
+    if (error.status !== 404) {
+      return false;
+    }
+    writeInsightsSurfaceUnavailable(error, family);
+    return true;
+  };
+}
 function writeInsightsError(error, family) {
   if (error instanceof InsightsHttpError) {
     const context = httpErrorContext(error);
@@ -6357,22 +7489,34 @@ function compareRowKeys(a, b) {
   }
   return a < b ? -1 : 1;
 }
+function claimHttpError(requestError, onHttpError) {
+  if (requestError instanceof InsightsHttpError && onHttpError?.(requestError)) {
+    ensureFailureExit();
+    return true;
+  }
+  return false;
+}
 async function executeInsightsList(options, fetchList, spec) {
   const config = await resolveInsightsConfig();
   if (config === null) {
     return;
   }
-  const [requestError, response] = await catchError2(fetchList(config));
+  const [requestError, response] = await catchError(fetchList(config));
   if (requestError) {
+    if (claimHttpError(requestError, spec.onHttpError)) {
+      return;
+    }
     writeInsightsError(requestError, spec.family);
     return;
   }
-  const [contractError, projected] = catchError2(() => spec.project(response));
+  const [contractError, rows] = catchError(() => {
+    const projected = spec.project(response);
+    return spec.finalize ? spec.finalize(projected) : projected;
+  });
   if (contractError) {
     writeInsightsError(contractError, spec.family);
     return;
   }
-  const rows = spec.finalize ? spec.finalize(projected) : projected;
   const offset = options.offset ?? 0;
   const page = rows.slice(offset, offset + options.limit);
   const pagination = new Pagination({
@@ -6381,12 +7525,13 @@ async function executeInsightsList(options, fetchList, spec) {
     offset,
     total: rows.length
   });
+  const instructions = spec.instructions(rows, page, pagination.HasMore);
   OutputFormatter.success({
     Result: RESULTS.Success,
     Code: spec.code,
     Data: page,
     Pagination: pagination,
-    Instructions: spec.instructions(rows, page, pagination.HasMore)
+    ...instructions === "" ? {} : { Instructions: instructions }
   });
 }
 async function executeInsightsGet(fetchOne, spec) {
@@ -6394,25 +7539,25 @@ async function executeInsightsGet(fetchOne, spec) {
   if (config === null) {
     return;
   }
-  const [requestError, response] = await catchError2(fetchOne(config));
+  const [requestError, response] = await catchError(fetchOne(config));
   if (requestError) {
-    if (requestError instanceof InsightsHttpError && spec.onHttpError?.(requestError)) {
-      ensureFailureExit();
+    if (claimHttpError(requestError, spec.onHttpError)) {
       return;
     }
     writeInsightsError(requestError, spec.family);
     return;
   }
-  const [contractError, data] = catchError2(() => spec.project(response, config));
+  const [contractError, data] = catchError(() => spec.project(response, config));
   if (contractError) {
     writeInsightsError(contractError, spec.family);
     return;
   }
+  const instructions = spec.instructions(data);
   OutputFormatter.success({
     Result: RESULTS.Success,
     Code: spec.code,
     Data: data,
-    Instructions: spec.instructions(data)
+    ...instructions === "" ? {} : { Instructions: instructions }
   });
 }
 
@@ -6423,6 +7568,38 @@ function isRecord2(value) {
 function asRecord(value) {
   return isRecord2(value) ? value : null;
 }
+function pickScalar(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return null;
+}
+function createContractGuards(newError) {
+  return {
+    requireKnownShape: (dto, fields, subject) => {
+      if (fields.some((field) => dto[field] !== undefined)) {
+        return;
+      }
+      throw newError(`Insights returned ${subject} carrying none of its expected fields (${fields.join(", ")}); the response shape does not match the contract`);
+    },
+    requireArrayField: (dto, field, subject) => {
+      const value = dto[field];
+      if (value === undefined || value === null) {
+        return [];
+      }
+      if (!Array.isArray(value)) {
+        throw newError(`Insights returned ${subject} whose ${field} is not an array`);
+      }
+      return value;
+    }
+  };
+}
 
 // src/utils/alerts.ts
 class AlertContractError extends Error {
@@ -6431,25 +7608,14 @@ class AlertContractError extends Error {
     this.name = "AlertContractError";
   }
 }
+var { requireArrayField, requireKnownShape } = createContractGuards((message) => new AlertContractError(message));
 var ALERTS_FAMILY = {
   subject: "Alert",
   forbiddenExtra: "A 403 here usually means the caller's Orchestrator folder access could not be resolved rather than an entitlement problem, so check the active tenant and your folder permissions first. 'uip insights alerts check-entitlement' reports entitlement separately.",
   isContractError: (error) => error instanceof AlertContractError
 };
 var MAX_INT32 = 2147483647;
-function parseRouteId(raw, label) {
-  return parseBoundedInt(raw, label, { min: 1, max: MAX_INT32 });
-}
-function pickScalar(value) {
-  if (value === undefined || value === null) {
-    return null;
-  }
-  const kind = typeof value;
-  if (kind === "string" || kind === "number" || kind === "boolean") {
-    return value;
-  }
-  return null;
-}
+var parseRouteId = (label) => (raw) => parseBoundedInt(raw, label, { min: 1, max: MAX_INT32 });
 var ENGINE_NAMES = { 0: "curated", 1: "query" };
 var SIDE_EFFECT_NOTE = "This command also runs an entitlement and permission check that can bootstrap Insights permissions and queue a warehouse warmup, so it is not a free read.";
 var ENTITLEMENT_SIDE_EFFECT_NOTE = "Running this check can bootstrap Insights permissions and queue a warehouse warmup, so it is not a free read.";
@@ -6468,7 +7634,7 @@ var ENGINE_UNKNOWN_NOTE = "One or more alerts report an alert engine this CLI do
 var AGENTIC_BASE_NOTE = `Only active alert definitions tied to this process key are returned. ${FOLDER_KEYS_NOTE}`;
 var ENTITLED_TRUE_NOTE = "True means the organization holds the Insights full-mode entitlement and the current caller passed the Insights admin check. While this is true, 'alerts list' and 'alerts get' are not entitlement-filtered, so an earlier partial-result warning from those commands does not apply. They still return only active alert definitions.";
 var ENTITLED_FALSE_NOTE = "False means at least one of three things: the organization has no Insights full-mode entitlement, the caller is not an Insights admin, or the Insights portal service is unreachable in this tenant. The backend does not say which. While this is false, 'alerts list' and 'alerts get' return only alerts tied to a process key. The agentic list is unaffected.";
-var DEFINITION_NOT_FOUND_INSTRUCTIONS = `A 404 can mean the ID does not exist, the alert is inactive, or the alert was filtered out because the tenant is not entitled to Insights alerts. ${ENTITLEMENT_FILTER_CLAUSE} 'uip insights alerts list' applies the same filter, so an ID missing there is not proof it does not exist. Run 'uip insights alerts check-entitlement' first. Both of those commands also run the entitlement and permission check, so neither is a free read.`;
+var DEFINITION_NOT_FOUND_INSTRUCTIONS = `A 404 can mean the ID does not exist, the alert is inactive, the alert was filtered out because the tenant is not entitled to Insights alerts, or Insights alerts are not enabled on this deployment at all. ${ENTITLEMENT_FILTER_CLAUSE} 'uip insights alerts list' applies the same filter, so an ID missing there is not proof it does not exist; if that command also reports the surface unavailable, this deployment does not serve alerts. Run 'uip insights alerts check-entitlement' first. Both of those commands also run the entitlement and permission check, so neither is a free read.`;
 function parseScopeValues(value) {
   if (value === undefined || value === null) {
     return [];
@@ -6476,7 +7642,7 @@ function parseScopeValues(value) {
   if (typeof value !== "string") {
     return (Array.isArray(value) ? value : [value]).map(pickScalar);
   }
-  const [parseError, parsed] = catchError2(() => JSON.parse(value));
+  const [parseError, parsed] = catchError(() => JSON.parse(value));
   if (!parseError && Array.isArray(parsed)) {
     return parsed.map(pickScalar);
   }
@@ -6624,7 +7790,8 @@ async function executeAlertsList(options, fetchList, variant) {
     family: ALERTS_FAMILY,
     project: projectDefinitionRows,
     finalize: (rows) => [...rows].sort(compareDefinitionRows),
-    instructions: (rows, page, hasMore) => buildListInstructions(variant, rows, page, hasMore)
+    instructions: (rows, page, hasMore) => buildListInstructions(variant, rows, page, hasMore),
+    onHttpError: claimGatedSurface404(ALERTS_FAMILY)
   });
 }
 function buildGetInstructions(row) {
@@ -6658,8 +7825,11 @@ async function executeCheckEntitlement() {
   if (config === null) {
     return;
   }
-  const [requestError, response] = await catchError2(checkAlertEntitlement(config));
+  const [requestError, response] = await catchError(checkAlertEntitlement(config));
   if (requestError) {
+    if (requestError instanceof InsightsHttpError && claimGatedSurface404(ALERTS_FAMILY)(requestError)) {
+      return;
+    }
     writeInsightsError(requestError, ALERTS_FAMILY);
     return;
   }
@@ -6674,6 +7844,157 @@ async function executeCheckEntitlement() {
     Instructions: `${response ? ENTITLED_TRUE_NOTE : ENTITLED_FALSE_NOTE} ${ENTITLEMENT_SIDE_EFFECT_NOTE}`
   });
 }
+var BACKEND_HISTORY_ROW_CAP = 1000;
+var HISTORY_ROW_FIELDS = [
+  "alertId",
+  "alertName",
+  "timestamp",
+  "severity",
+  "triggerSpec",
+  "computationSpec",
+  "folderNames",
+  "alertDeliveryId"
+];
+var METRICS_FIELDS = [
+  "groupNames",
+  "endTimeIntervals",
+  "alertTriggerCount"
+];
+var DELIVERY_FIELDS = ["id", "type", "recipientIds", "tenantKey"];
+var HISTORY_EMPTY_NOTE = "No alert history rows matched in the requested time range for the current caller. That is not proof the alert never triggered.";
+var HISTORY_OVER_PAGED_SCOPE = " in the requested time range";
+var HISTORY_TRUNCATED_NOTE = `The backend returned its maximum of ${BACKEND_HISTORY_ROW_CAP} rows, newest first, so older triggers in this time range are not included. Narrow the time window to see them.`;
+var HISTORY_NOT_NOTIFICATION_NOTE = "A history row records that the alert fired, not that anyone was notified.";
+var HISTORY_TIME_UNIT_NOTE = "TriggeredAt is epoch seconds, not milliseconds or an ISO timestamp.";
+var HISTORY_FOLDER_FILTER_NOTE = "--folder-name matches folders by flattening each trigger's folder list, so a trigger sitting in two of the requested folders is returned twice here and counted twice by 'get-metrics'. Triggers that record no folder are dropped from a folder-filtered result.";
+var METRICS_GROUPING_NOTE = "Results are grouped by alert type. Counts holds one row of trigger counts per entry in Groups, and each count pairs with the interval end time at the same index in IntervalEndTimes.";
+function projectAlertHistoryRow(raw) {
+  const dto = asRecord(raw);
+  if (!dto) {
+    throw new AlertContractError("Insights returned an alert history row that is not an object");
+  }
+  requireKnownShape(dto, HISTORY_ROW_FIELDS, "an alert history row");
+  const trigger = asRecord(dto.triggerSpec);
+  const computation = asRecord(dto.computationSpec);
+  return {
+    alertId: dto.alertId ?? null,
+    alertName: dto.alertName ?? null,
+    triggeredAt: dto.timestamp ?? null,
+    severity: dto.severity ?? null,
+    operator: trigger?.type ?? null,
+    threshold: trigger?.value ?? null,
+    metric: computation?.computation ?? null,
+    metricState: computation?.filterValue ?? null,
+    deliveryId: dto.alertDeliveryId ?? null
+  };
+}
+function projectHistoryRows(response) {
+  if (!Array.isArray(response)) {
+    throw new AlertContractError("Insights returned an alert history list that is not an array");
+  }
+  return response.map(projectAlertHistoryRow);
+}
+function hasFolderFilter(request) {
+  return Array.isArray(request.folders) && request.folders.length > 0;
+}
+function buildHistoryListInstructions(rows, page, hasMore, folderFiltered) {
+  const parts = [];
+  if (rows.length === 0) {
+    parts.push(HISTORY_EMPTY_NOTE);
+  } else if (page.length === 0) {
+    parts.push(overPagedNote(rows.length, HISTORY_OVER_PAGED_SCOPE));
+  }
+  if (rows.length === BACKEND_HISTORY_ROW_CAP) {
+    parts.push(HISTORY_TRUNCATED_NOTE);
+  }
+  if (hasMore) {
+    parts.push(truncatedNote("a trigger"));
+  }
+  if (page.length > 0) {
+    parts.push(HISTORY_TIME_UNIT_NOTE);
+  }
+  if (folderFiltered) {
+    parts.push(HISTORY_FOLDER_FILTER_NOTE);
+  }
+  parts.push(HISTORY_NOT_NOTIFICATION_NOTE);
+  return parts.join(" ");
+}
+async function executeAlertHistoryList(options, request) {
+  await executeInsightsList(options, (config) => listAlertHistoryDetails(config, request), {
+    code: "InsightsAlertHistoryList",
+    family: ALERTS_FAMILY,
+    project: projectHistoryRows,
+    instructions: (rows, page, hasMore) => buildHistoryListInstructions(rows, page, hasMore, hasFolderFilter(request)),
+    onHttpError: claimGatedSurface404(ALERTS_FAMILY)
+  });
+}
+function buildMetricsInstructions(folderFiltered) {
+  const parts = [METRICS_GROUPING_NOTE];
+  if (folderFiltered) {
+    parts.push(HISTORY_FOLDER_FILTER_NOTE);
+  }
+  return parts.join(" ");
+}
+function projectAlertHistoryMetrics(raw) {
+  const dto = asRecord(raw);
+  if (!dto) {
+    throw new AlertContractError("Insights returned alert history metrics that are not an object");
+  }
+  const subject = "alert history metrics";
+  requireKnownShape(dto, METRICS_FIELDS, subject);
+  return {
+    groups: requireArrayField(dto, "groupNames", subject),
+    intervalEndTimes: requireArrayField(dto, "endTimeIntervals", subject),
+    counts: requireArrayField(dto, "alertTriggerCount", subject)
+  };
+}
+async function executeAlertHistoryMetrics(request) {
+  await executeInsightsGet((config) => getAlertHistoryMetrics(config, request), {
+    code: "InsightsAlertHistoryMetrics",
+    family: ALERTS_FAMILY,
+    project: (response) => projectAlertHistoryMetrics(response),
+    onHttpError: claimGatedSurface404(ALERTS_FAMILY),
+    instructions: () => buildMetricsInstructions(hasFolderFilter(request))
+  });
+}
+var DELIVERY_INSTRUCTIONS = "Recipient identities are not returned by design. Use RecipientCount to confirm the delivery has recipients before referencing it.";
+var DELIVERY_NOT_FOUND_INSTRUCTIONS = "A 404 can mean the delivery ID does not exist or the delivery belongs to another tenant. Take the DeliveryId from a row returned by 'uip insights alerts list' or 'uip insights alert-history list'.";
+function projectAlertDelivery(raw, sessionTenantId) {
+  const dto = asRecord(raw);
+  if (!dto) {
+    throw new AlertContractError("Insights returned an alert delivery that is not an object");
+  }
+  requireKnownShape(dto, DELIVERY_FIELDS, "an alert delivery");
+  return {
+    id: dto.id ?? null,
+    type: dto.type ?? null,
+    recipientCount: requireArrayField(dto, "recipientIds", "an alert delivery").length,
+    tenantMatches: typeof dto.tenantKey === "string" && dto.tenantKey.toLowerCase() === sessionTenantId.toLowerCase()
+  };
+}
+async function executeAlertDeliveryGet(deliveryId) {
+  await executeInsightsGet((config) => getDefaultDelivery(config, deliveryId), {
+    code: "InsightsAlertDeliveryGet",
+    family: ALERTS_FAMILY,
+    project: (response, config) => projectAlertDelivery(response, config.tenantId),
+    instructions: () => DELIVERY_INSTRUCTIONS,
+    onHttpError: (error) => {
+      if (error.status !== 404) {
+        return false;
+      }
+      writeInsightsNotFound(error, `Alert delivery ${deliveryId} was not found in the current tenant.`, DELIVERY_NOT_FOUND_INSTRUCTIONS);
+      return true;
+    }
+  });
+}
+
+// src/commands/alert-deliveries.ts
+function registerAlertDeliveriesCommand(program2) {
+  const deliveriesCmd = program2.command("alert-deliveries").description("Read UiPath Insights alert delivery metadata");
+  deliveriesCmd.command("get").description("Get metadata for one alert delivery by its integer ID").argument("<delivery-id>", "Alert delivery ID (integer)", parseRouteId("<delivery-id>")).trackedAction(processContext, async (deliveryId) => {
+    await executeAlertDeliveryGet(String(deliveryId));
+  });
+}
 
 // src/utils/list-options.ts
 var DEFAULT_LIMIT = 50;
@@ -6681,10 +8002,119 @@ function addListPaginationOptions(cmd) {
   return cmd.option("-l, --limit <number>", "Maximum rows to return", parseLimit, DEFAULT_LIMIT).option("-o, --offset <number>", "Rows to skip before returning results", parseOffset);
 }
 
-// src/commands/alerts.ts
-function parseAlertId(raw) {
-  return parseRouteId(raw, "<alert-id>");
+// src/utils/validate.ts
+var TIME_GROUPING_SIZES = ["FifteenMinutes", "Hour", "Day"];
+var TENANT_FIELD_NAMES_LOWER = new Set(["tenantkey", "tenantid"]);
+function validateTimeSelection(selection) {
+  const hasRelative = selection.timeRange !== undefined;
+  const hasAbsolute = selection.since !== undefined || selection.until !== undefined;
+  if (hasRelative && hasAbsolute) {
+    return {
+      message: "Provide either --time-range or the --since and --until pair, not both.",
+      instructions: "Use --time-range <minutes> for a window ending now, or --since <epoch-seconds> with --until <epoch-seconds> for a fixed window."
+    };
+  }
+  if (!hasRelative && !hasAbsolute) {
+    return {
+      message: "Missing required field: a time selection.",
+      instructions: "Pass --time-range <minutes>, or --since <epoch-seconds> (optionally with --until)."
+    };
+  }
+  if (selection.since !== undefined && selection.until !== undefined && selection.since >= selection.until) {
+    return {
+      message: "--since must be earlier than --until.",
+      instructions: "Make --until strictly greater than --since. Both are epoch seconds (not milliseconds)."
+    };
+  }
+  return null;
+}
+
+// src/commands/alert-history.ts
+var MAX_EPOCH_SECONDS = 253402300799;
+var MAX_TIME_RANGE_MINUTES = 527040;
+var MIN_START_TIMESTAMP = 1;
+var SEVERITIES = ["INFO", "WARN", "ERROR", "NORMAL"];
+var parseTimeRange = (raw) => parseBoundedInt(raw, "--time-range", {
+  min: 1,
+  max: MAX_TIME_RANGE_MINUTES
+});
+var parseEpochSeconds = (flag) => (raw) => parseBoundedInt(raw, flag, { min: 0, max: MAX_EPOCH_SECONDS });
+function addHistoryFilterOptions(cmd) {
+  return cmd.option("--time-range <minutes>", "Relative window ending now", parseTimeRange).option("--since <epoch-seconds>", "Absolute lower bound, epoch seconds", parseEpochSeconds("--since")).option("--until <epoch-seconds>", "Absolute upper bound, epoch seconds", parseEpochSeconds("--until")).option("--alert-name <name>", "Filter to one alert name").option("--folder-name <names...>", "Filter by folder name (names, not folder keys; repeatable)").addOption(new Option("--severity <severities...>", "Filter by severity, repeatable (NORMAL is kept for backwards compatibility)").choices(SEVERITIES));
+}
+function effectiveLowerBound(options) {
+  if (options.since !== undefined) {
+    return Math.max(options.since, MIN_START_TIMESTAMP);
+  }
+  if (options.until !== undefined) {
+    return MIN_START_TIMESTAMP;
+  }
+  return;
+}
+function flooredSelection(options) {
+  return {
+    timeRange: options.timeRange,
+    since: effectiveLowerBound(options),
+    until: options.until
+  };
+}
+function validateHistoryOptions(options) {
+  const timeError = validateTimeSelection(flooredSelection(options));
+  if (timeError) {
+    failValidation(timeError.message, timeError.instructions);
+    return false;
+  }
+  if (options.alertName !== undefined && options.alertName.trim() === "") {
+    failValidation("--alert-name must not be empty.", "Pass the alert name shown on an 'alerts list' row, or omit the flag to include all alerts.");
+    return false;
+  }
+  if (options.folderName?.some((name) => name.trim() === "")) {
+    failValidation("--folder-name values must not be empty.", "Pass folder names (not folder keys), or omit the flag to include all folders.");
+    return false;
+  }
+  return true;
+}
+function buildHistoryRequest(options) {
+  const body = {};
+  if (options.timeRange !== undefined) {
+    body.startTimeStamp = Math.max(Math.floor(Date.now() / 1000) - options.timeRange * 60, MIN_START_TIMESTAMP);
+  } else {
+    body.startTimeStamp = flooredSelection(options).since ?? MIN_START_TIMESTAMP;
+    if (options.until !== undefined) {
+      body.endTimeStamp = options.until;
+    }
+  }
+  if (options.alertName !== undefined) {
+    body.alertName = options.alertName.trim();
+  }
+  if (options.folderName !== undefined) {
+    body.folders = options.folderName.map((name) => name.trim());
+  }
+  if (options.severity !== undefined) {
+    body.severity = options.severity;
+  }
+  return body;
+}
+function registerAlertHistoryCommand(program2) {
+  const historyCmd = program2.command("alert-history").description("Read UiPath Insights alert trigger history");
+  addListPaginationOptions(addHistoryFilterOptions(historyCmd.command("list").description("List alert trigger history rows in a time window, newest first"))).trackedAction(processContext, async (options) => {
+    if (!validateHistoryOptions(options)) {
+      return;
+    }
+    await executeAlertHistoryList(options, buildHistoryRequest(options));
+  });
+  addHistoryFilterOptions(historyCmd.command("get-metrics").description("Get alert trigger counts per time interval, grouped by alert type")).addOption(new Option("--time-grouping <size>", "Bucket size for the metric intervals").choices([...TIME_GROUPING_SIZES]).makeOptionMandatory()).trackedAction(processContext, async (options) => {
+    if (!validateHistoryOptions(options)) {
+      return;
+    }
+    await executeAlertHistoryMetrics({
+      ...buildHistoryRequest(options),
+      timeGroupingSize: options.timeGrouping
+    });
+  });
 }
+
+// src/commands/alerts.ts
 function registerAlertsCommand(program2) {
   const alertsCmd = program2.command("alerts").description("Read UiPath Insights real-time alert definitions");
   addListPaginationOptions(alertsCmd.command("list").description("List alert definitions visible to the current caller; with --agentic, the definitions for one process key").option("--agentic", "Use the agentic route, scoped to one process key").option("--process-key <key>", "Process key to scope the agentic list to (required with --agentic)")).trackedAction(processContext, async (options) => {
@@ -6700,7 +8130,7 @@ function registerAlertsCommand(program2) {
     }
     return executeAlertsList(options, (config) => listAlertDefinitions(config, {}), "all");
   });
-  alertsCmd.command("get").description("Get one alert definition by its integer ID").argument("<alert-id>", "Alert definition ID (integer)", parseAlertId).trackedAction(processContext, async (alertId) => {
+  alertsCmd.command("get").description("Get one alert definition by its integer ID").argument("<alert-id>", "Alert definition ID (integer)", parseRouteId("<alert-id>")).trackedAction(processContext, async (alertId) => {
     await executeAlertGet(String(alertId));
   });
   alertsCmd.command("check-entitlement").description("Check whether this tenant is confirmed entitled to Insights alerts").trackedAction(processContext, async () => {
@@ -6757,7 +8187,8 @@ async function executeFilterList(options, fetchList, toRows, code) {
     family: FILTERS_FAMILY,
     project: toRows,
     finalize: dedupeAndSortRows,
-    instructions: (rows, page, hasMore) => listInstructions(rows.length, page.length, hasMore)
+    instructions: (rows, page, hasMore) => listInstructions(rows.length, page.length, hasMore),
+    onHttpError: claimGatedSurface404(FILTERS_FAMILY)
   });
 }
 
@@ -6878,7 +8309,7 @@ async function executeJobsEndpoint(options, endpointPath, code) {
     processContext.exit(1);
     return;
   }
-  const [configErr, config] = await catchError2(createInsightsConfig(options.tenant));
+  const [configErr, config] = await catchError(createInsightsConfig(options.tenant));
   if (configErr) {
     OutputFormatter.error({
       Result: RESULTS.Failure,
@@ -6889,7 +8320,7 @@ async function executeJobsEndpoint(options, endpointPath, code) {
     return;
   }
   const body = buildRequestBody(config.tenantId, options);
-  const [apiErr, result] = await catchError2(insightsPost(config, endpointPath, body));
+  const [apiErr, result] = await catchError(insightsPost(config, endpointPath, body));
   if (apiErr) {
     OutputFormatter.error({
       Result: RESULTS.Failure,
@@ -6930,6 +8361,171 @@ function registerJobsCommand(program2) {
   });
 }
 
+// src/utils/rbac.ts
+class RbacContractError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RbacContractError";
+  }
+}
+var { requireArrayField: requireArrayField2, requireKnownShape: requireKnownShape2 } = createContractGuards((message) => new RbacContractError(message));
+var MANAGEMENT_VIEW_NOTE = "Reading Insights RBAC requires the Insights Management View permission in the active tenant. This route also returns 403 for a session with no user identity, such as one signed in with client credentials, and such a session cannot read Insights RBAC at all.";
+function rbacFamily(subject) {
+  return {
+    subject,
+    forbiddenExtra: MANAGEMENT_VIEW_NOTE,
+    isContractError: (error) => error instanceof RbacContractError
+  };
+}
+var EMPTY_LIST_SUFFIX = "An empty list is a successful result, not an error.";
+function unwrapPortalBody(raw, subject) {
+  const record = asRecord(raw);
+  if (record && typeof record.isSuccess === "boolean") {
+    if (record.isSuccess !== true) {
+      throw new RbacContractError(`Insights reported a failed ${subject} result inside a success response`);
+    }
+    if (record.result === undefined || record.result === null) {
+      throw new RbacContractError(`Insights returned a legacy ${subject} envelope without a result`);
+    }
+    return record.result;
+  }
+  return raw;
+}
+var PRINCIPAL_FIELDS = ["id", "name", "roles"];
+var PRINCIPAL_WITHHELD_NOTE = "This view omits email and the nested role IDs. Pass --include-email to include them.";
+function roleName(role) {
+  return typeof role === "string" ? role : pickScalar(asRecord(role)?.name);
+}
+function safeRole(role) {
+  return { name: roleName(role) };
+}
+function fullRole(role) {
+  if (typeof role === "string") {
+    return { id: null, name: role };
+  }
+  return { id: pickScalar(asRecord(role)?.id), name: roleName(role) };
+}
+function projectPrincipal(raw, subject, full) {
+  const dto = asRecord(raw);
+  if (!dto) {
+    throw new RbacContractError(`Insights returned a ${subject} that is not an object`);
+  }
+  const noun = `a ${subject}`;
+  requireKnownShape2(dto, PRINCIPAL_FIELDS, noun);
+  const roles = requireArrayField2(dto, "roles", noun);
+  const row = {
+    id: pickScalar(dto.id),
+    name: pickScalar(dto.name),
+    roles: full ? roles.map(fullRole) : roles.map(safeRole)
+  };
+  if (full) {
+    row.email = pickScalar(dto.email);
+  }
+  return row;
+}
+function projectRowAt(row, index, subject, project, full) {
+  try {
+    return project(row, subject, full);
+  } catch (error) {
+    if (error instanceof RbacContractError) {
+      throw new RbacContractError(`${error.message} (list element ${index})`);
+    }
+    throw error;
+  }
+}
+function projectListRows(response, subject, project, full) {
+  const body = unwrapPortalBody(response, subject);
+  if (!Array.isArray(body)) {
+    throw new RbacContractError(`Insights returned a ${subject} list that is not an array`);
+  }
+  const rows = body;
+  const keyed = rows.map((raw, index) => {
+    const row = projectRowAt(raw, index, subject, project, full);
+    const tieKey = full ? JSON.stringify(projectRowAt(raw, index, subject, project, false)) : JSON.stringify(row);
+    return { row, tieKey };
+  });
+  keyed.sort(compareRbacRows);
+  return keyed.map((entry) => entry.row);
+}
+function sortKey(value) {
+  return String(pickScalar(value) ?? "");
+}
+function compareRbacRows(a, b) {
+  const nameA = sortKey(a.row.name);
+  const nameB = sortKey(b.row.name);
+  const byFoldedName = compareRowKeys(nameA.toLowerCase(), nameB.toLowerCase());
+  if (byFoldedName !== 0) {
+    return byFoldedName;
+  }
+  const byName = compareRowKeys(nameA, nameB);
+  if (byName !== 0) {
+    return byName;
+  }
+  const byId = compareRowKeys(sortKey(a.row.id), sortKey(b.row.id));
+  if (byId !== 0) {
+    return byId;
+  }
+  const bySharedKey = compareRowKeys(a.tieKey, b.tieKey);
+  if (bySharedKey !== 0) {
+    return bySharedKey;
+  }
+  return compareRowKeys(JSON.stringify(a.row), JSON.stringify(b.row));
+}
+function joinParts(parts) {
+  return parts.filter((part) => part !== "").join(" ");
+}
+function buildListInstructions2(spec, total, returned, hasMore, full) {
+  if (total === 0) {
+    return joinParts([spec.emptyNote, EMPTY_LIST_SUFFIX]);
+  }
+  const withheld = full ? "" : spec.withheldNote;
+  if (returned === 0) {
+    return joinParts([overPagedNote(total), spec.standingNote, withheld]);
+  }
+  return joinParts([
+    spec.standingNote,
+    withheld,
+    hasMore ? truncatedNote(`a ${spec.noun}`) : ""
+  ]);
+}
+function writeRbacListNotFound(error, subject) {
+  writeInsightsNotFound(error, `The Insights ${subject} list returned HTTP 404.`, "This route cannot miss for data reasons; the active tenant likely does not have the Insights Portal service provisioned. Do not retry until the tenant changes.");
+}
+async function executeRbacList(options, fetchList, family, spec) {
+  const full = options.includeEmail === true;
+  await executeInsightsList(options, fetchList, {
+    code: spec.code,
+    family,
+    project: (response) => projectListRows(response, family.subject, spec.project, full),
+    instructions: (rows, page, hasMore) => buildListInstructions2(spec, rows.length, page.length, hasMore, full),
+    onHttpError: (error) => {
+      if (error.status !== 404) {
+        return false;
+      }
+      writeRbacListNotFound(error, family.subject);
+      return true;
+    }
+  });
+}
+
+// src/commands/users.ts
+var USERS_FAMILY = rbacFamily("User");
+var USERS_LIST_NOTE = "Roles shown are the user's Insights roles in the active tenant, by name. A user's row is kept even when directory enrichment fails.";
+var USERS_EMPTY_NOTE = "A user's row is kept even when directory enrichment fails.";
+function registerUsersCommand(program2) {
+  const usersCmd = program2.command("users").description("Read the Insights users of the active tenant");
+  addListPaginationOptions(usersCmd.command("list").description("List tenant users visible to the current caller, with their Insights role names")).option("--include-email", "Include email addresses and nested role IDs in the output").trackedAction(processContext, async (options) => {
+    await executeRbacList(options, listUsers, USERS_FAMILY, {
+      code: "InsightsUsersList",
+      project: projectPrincipal,
+      standingNote: USERS_LIST_NOTE,
+      withheldNote: PRINCIPAL_WITHHELD_NOTE,
+      emptyNote: USERS_EMPTY_NOTE,
+      noun: "user"
+    });
+  });
+}
+
 // src/tool.ts
 var metadata = {
   name: "insights-tool",
@@ -6944,8 +8540,11 @@ var registerCommands = async (program2) => {
   registerFilterQueuesCommand(program2);
   registerFilterMachinesCommand(program2);
   registerAlertsCommand(program2);
+  registerAlertHistoryCommand(program2);
+  registerAlertDeliveriesCommand(program2);
+  registerUsersCommand(program2);
 };
 
 export { Command, metadata, registerCommands };
 
-//# debugId=ACE9F3EC37E22D1E64756E2164756E21
+//# debugId=EAF8B77C7D18E99C64756E2164756E21