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

package/dist/{tool-fw3qn1x6.js → tool-g5a9xk4w.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/ixp-tool",
   license: "MIT",
-  version: "1.201.0",
+  version: "1.202.0-preview.136",
   description: "Manage UiPath IXP projects, prompts, predictions, and model publishing.",
   private: false,
   repository: {
@@ -2155,11 +2143,753 @@ var package_default = {
   }
 };
 
+// ../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;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    await fs.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+    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 {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  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;
+  }
+}
+
+// ../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;
+  }
+  let hex = "";
+  for (const word of state) {
+    hex += word.toString(16).padStart(8, "0");
+  }
+  return hex;
+}
+function resolveSha256Hex() {
+  try {
+    const nodeCrypto = __require("node:crypto");
+    const createHash = nodeCrypto?.createHash;
+    if (typeof createHash !== "function") {
+      return sha256Hex;
+    }
+    const native = (input) => createHash("sha256").update(input, "utf8").digest("hex");
+    return native("abc") === sha256Hex("abc") ? native : sha256Hex;
+  } catch {
+    return sha256Hex;
+  }
+}
+var cachedSha256Hex;
+function digest(input) {
+  cachedSha256Hex ??= resolveSha256Hex();
+  return cachedSha256Hex(input);
+}
+function pseudonymize(input) {
+  return digest(`${PSEUDONYM_DOMAIN}${input}`).slice(0, PSEUDONYM_HEX_LENGTH);
+}
+
+// ../common/src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// ../common/src/telemetry/supplied-values.ts
+var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
+function activeEntries() {
+  const existing = suppliedValuesSlot.get();
+  return Array.isArray(existing) ? existing : [];
+}
+var MIN_SCRUBBABLE_LENGTH = 4;
+function recordSuppliedArgumentValues(values) {
+  const flat = [];
+  const push = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        push(item);
+      }
+      return;
+    }
+    if (typeof value === "string" && value.length >= MIN_SCRUBBABLE_LENGTH) {
+      flat.push(value);
+    }
+  };
+  push(values);
+  const entry = { values: flat };
+  suppliedValuesSlot.set([...activeEntries(), entry]);
+  return entry;
+}
+function releaseSuppliedArgumentValues(entry) {
+  suppliedValuesSlot.set(activeEntries().filter((held) => held !== entry));
+}
+function getSuppliedArgumentValues() {
+  const all = new Set;
+  for (const entry of activeEntries()) {
+    for (const value of entry.values) {
+      all.add(value);
+    }
+  }
+  return [...all].sort((a, b) => b.length - a.length);
+}
+
+// ../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 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 catchError2(fnOrPromise) {
+function catchError(fnOrPromise) {
   if (isPromiseLike(fnOrPromise)) {
     return settlePromiseLike(fnOrPromise);
   }
@@ -2170,17 +2900,11 @@ function catchError2(fnOrPromise) {
     }
     return [undefined, result];
   } catch (error) {
-    return [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ];
+    return [toError(error), undefined];
   }
 }
 function settlePromiseLike(thenable) {
-  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
-    error instanceof Error ? error : new Error(String(error)),
-    undefined
-  ]);
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
 }
 
 // ../common/src/error-handler.ts
@@ -2214,8 +2938,8 @@ var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most
 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"]);
 var LOCAL_PERMISSION_MESSAGE_PATTERN = /\b(EACCES|EPERM|EROFS)\b/;
-function localPermissionInstructions(code, path) {
-  const target = path !== undefined ? `'${path}'` : "a local file or resource";
+function localPermissionInstructions(code, path2) {
+  const target = path2 !== undefined ? `'${path2}'` : "a local file or resource";
   if (code === "EROFS") {
     return `The filesystem containing ${target} is read-only (EROFS), so the ` + "CLI could not write to it. This is a local environment problem, " + "not a UiPath service error — retrying will not help. Use a " + "writable location, or give this environment write access to the " + "path.";
   }
@@ -2251,12 +2975,12 @@ function describePermissionError(error) {
     const code = matchLocalPermissionCode(cur.code, message);
     if (!code)
       continue;
-    const path = localPermissionPath(cur.path, message);
+    const path2 = localPermissionPath(cur.path, message);
     return {
       code,
       message: message ?? code,
-      ...path !== undefined ? { path } : {},
-      instructions: localPermissionInstructions(code, path)
+      ...path2 !== undefined ? { path: path2 } : {},
+      instructions: localPermissionInstructions(code, path2)
     };
   }
   return;
@@ -2268,9 +2992,9 @@ function matchLocalPermissionCode(code, message) {
   const match = message ? LOCAL_PERMISSION_MESSAGE_PATTERN.exec(message) : null;
   return match ? match[1] : undefined;
 }
-function localPermissionPath(path, message) {
-  if (typeof path === "string")
-    return path;
+function localPermissionPath(path2, message) {
+  if (typeof path2 === "string")
+    return path2;
   return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
 }
 function* walkErrorGraph(error) {
@@ -2379,10 +3103,10 @@ async function extractErrorDetails(error, options) {
   let parsedBody;
   const textFn = response?.text?.bind(response);
   if (textFn) {
-    const [bodyError, body] = await catchError2((async () => textFn())());
+    const [bodyError, body] = await catchError((async () => textFn())());
     if (!bodyError && body) {
       rawBody = body;
-      const [parseError, parsed] = catchError2(() => JSON.parse(body));
+      const [parseError, parsed] = catchError(() => JSON.parse(body));
       if (!parseError && parsed && typeof parsed === "object") {
         parsedBody = parsed;
         if (parsedBody.errors && typeof parsedBody.errors === "object") {
@@ -2485,7 +3209,7 @@ async function extractErrorDetails(error, options) {
   } else if (typeof err.message === "string") {
     details = err.message;
   } else {
-    details = String(error);
+    details = describeThrownValue(error);
   }
   const context = {};
   if (status) {
@@ -2557,73 +3281,14 @@ async function extractErrorDetails(error, options) {
     ...parsedErrors ? { parsedErrors } : {}
   };
 }
-// ../../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;
-function singleton(ctorOrName) {
-  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
-  const key = Symbol.for(PREFIX + name);
-  return {
-    get(fallback) {
-      return _g[key] ?? fallback;
-    },
-    set(value) {
-      _g[key] = value;
-    },
-    clear() {
-      delete _g[key];
-    },
-    getOrInit(factory, guard) {
-      const existing = _g[key];
-      if (existing != null && typeof existing === "object") {
-        if (!guard || guard(existing)) {
-          return existing;
-        }
-      }
-      const instance = factory();
-      _g[key] = instance;
-      return instance;
-    }
-  };
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
 }
 
-// ../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/output-context.ts
 function createStorage() {
-  const [error, mod] = catchError2(() => __require("node:async_hooks"));
+  const [error, mod] = catchError(() => __require("node:async_hooks"));
   if (error || typeof mod?.AsyncLocalStorage !== "function") {
     return {
       getStore: () => {
@@ -2654,8 +3319,8 @@ function getOutputSink() {
 
 // ../common/src/logger.ts
 var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path) {
-  logFilePathSlot.set(path);
+function setGlobalLogFilePath(path2) {
+  logFilePathSlot.set(path2);
 }
 function getGlobalLogFilePath() {
   return logFilePathSlot.get("");
@@ -2692,7 +3357,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 */;
     }
@@ -2723,54 +3388,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;
@@ -2785,17 +3445,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;
@@ -2849,12 +3509,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);
     }));
   }
@@ -3109,7 +3769,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"]
   }));
@@ -3132,27 +3792,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
     })));
   }
@@ -3384,168 +4058,40 @@ function resolveTelemetrySession() {
   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;
-}
-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 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;
@@ -3565,36 +4111,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;
     }
   }
@@ -3603,8 +4152,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();
@@ -3612,7 +4160,8 @@ class TelemetryService {
     return {
       operationId,
       ...parentId !== undefined ? { parentId } : {},
-      id: this.generateId()
+      id: this.generateId(),
+      startedAt: startSpanClock().startedAt
     };
   }
   inboundParentIdFor(operationId) {
@@ -3623,58 +4172,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;
   }
@@ -3691,6 +4266,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");
 
@@ -3711,6 +4361,9 @@ function getGlobalTelemetryInstance() {
   }
   return;
 }
+function setGlobalTelemetryInstance(instance) {
+  telemetryInstanceSlot.set(instance);
+}
 var _localTelemetryInstance;
 function getTelemetryInstance() {
   const global = getGlobalTelemetryInstance();
@@ -3718,6 +4371,7 @@ function getTelemetryInstance() {
     return global;
   if (!_localTelemetryInstance) {
     _localTelemetryInstance = new TelemetryService(new LoggerTelemetryProvider, new NodeContextStorage);
+    setGlobalTelemetryInstance(_localTelemetryInstance);
   }
   return _localTelemetryInstance;
 }
@@ -3730,6 +4384,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",
@@ -3768,22 +4430,6 @@ var EXIT_CODES = {
   ValidationError: 3,
   TimeoutError: 4
 };
-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");
@@ -3848,19 +4494,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 = {};
@@ -3870,7 +4542,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;
@@ -3905,7 +4577,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);
         }
@@ -3916,10 +4588,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 ?? "");
@@ -3933,7 +4606,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()));
@@ -3943,7 +4616,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("");
@@ -3986,14 +4659,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)));
@@ -4001,7 +4674,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;
@@ -4047,6 +4720,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++) {
@@ -4054,7 +4728,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) {
@@ -4198,30 +4872,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
@@ -4297,6 +4977,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:";
@@ -4451,6 +5164,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);
@@ -4458,28 +5222,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 = [];
@@ -4494,7 +5304,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);
@@ -4534,68 +5344,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
@@ -4619,6 +5438,204 @@ var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 // ../common/src/constants.ts
 var DEFAULT_PAGE_SIZE = 50;
 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",
@@ -4743,8 +5760,81 @@ function getSdkUserAgentToken(pkg) {
 }
 // ../common/src/telemetry/ship-succeeded.ts
 var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
+function getShippedKeys() {
+  const existing = shippedKeysSlot.get();
+  if (existing) {
+    return existing;
+  }
+  const keys = new Set;
+  shippedKeysSlot.set(keys);
+  return keys;
+}
+function dedupeKey(payload) {
+  return [
+    payload.command_name,
+    payload.ship_kind,
+    payload.target,
+    payload.project_type,
+    payload.artifact_correlation_key ?? payload.package_version_key ?? payload.deployment_key ?? payload.solution_id ?? payload.package_name ?? ""
+  ].join("|");
+}
+function withPseudonymizedIdentifiers(payload) {
+  return {
+    ...payload,
+    ...payload.package_name === undefined ? {} : {
+      package_name: `package#${pseudonymize(payload.package_name)}`
+    },
+    ...payload.artifact_correlation_key === undefined ? {} : {
+      artifact_correlation_key: `artifact#${pseudonymize(payload.artifact_correlation_key)}`
+    }
+  };
+}
+function trackShipSucceeded(payload) {
+  const keys = getShippedKeys();
+  const key = dedupeKey(payload);
+  if (keys.has(key)) {
+    return false;
+  }
+  keys.add(key);
+  telemetry.trackEvent(CommonTelemetryEvents.ShipSucceeded, redactProperties(withPseudonymizedIdentifiers(payload)));
+  return true;
+}
 // ../common/src/tool-provider.ts
 var factorySlot = singleton("PackagerFactoryProvider");
+// ../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");
@@ -4758,7 +5848,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
@@ -4779,10 +5869,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.`);
@@ -4837,6 +5933,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";
@@ -4848,7 +5949,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: () => {
@@ -4864,9 +5965,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();
 
@@ -4897,8 +5998,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();
@@ -4979,7 +6080,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;
@@ -5063,27 +6164,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);
@@ -5109,8 +6231,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);
@@ -5119,9 +6241,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);
@@ -5132,20 +6254,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 {}
 }
@@ -5166,43 +6288,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);
@@ -5222,7 +6344,7 @@ var defaultLoadModule = async () => {
   if (!hostLoader) {
     return;
   }
-  const [error, mod] = await catchError(() => hostLoader());
+  const [error, mod] = await catchError2(() => hostLoader());
   if (error || !mod) {
     return;
   }
@@ -5248,7 +6370,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;
   }
@@ -5271,7 +6393,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) {
@@ -5298,7 +6420,7 @@ var tryRobotClientFallback = async (options = {}) => {
   } catch {
     return;
   } finally {
-    await catchError(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
+    await catchError2(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
   }
 };
 
@@ -5368,9 +6490,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 };
     }
@@ -5397,9 +6519,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,
@@ -5407,11 +6529,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,
@@ -5419,14 +6541,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" };
   }
@@ -5448,12 +6570,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}`);
   }
@@ -5482,10 +6604,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 {}
@@ -5503,11 +6625,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
@@ -5621,11 +6743,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 });
@@ -5999,7 +7121,7 @@ var TENANT_SELECTION_CODES = new Set([
 var package_default2 = {
   name: "@uipath/ixp-sdk",
   license: "MIT",
-  version: "1.201.0",
+  version: "1.202.0-preview.136",
   description: "SDK for the UiPath IXP (Intelligent eXtraction Platform) API — projects, taxonomies, prompts, predictions, and model publishing.",
   repository: {
     type: "git",
@@ -6127,27 +7249,27 @@ var DESIGNTIME_API_VERSION = "1.0";
 function designtimeBasePath(config) {
   return platformBasePath(config, "du_/api/designtimeapi");
 }
-function designtimeUrl(config, path) {
-  const separator = path.includes("?") ? "&" : "?";
-  return `${designtimeBasePath(config)}${path}${separator}api-version=${DESIGNTIME_API_VERSION}`;
+function designtimeUrl(config, path2) {
+  const separator = path2.includes("?") ? "&" : "?";
+  return `${designtimeBasePath(config)}${path2}${separator}api-version=${DESIGNTIME_API_VERSION}`;
 }
-async function designtimeGet(config, path, errorMessage2) {
-  return request(config, designtimeUrl(config, path), { method: "GET" }, errorMessage2);
+async function designtimeGet(config, path2, errorMessage2) {
+  return request(config, designtimeUrl(config, path2), { method: "GET" }, errorMessage2);
 }
-async function designtimePost(config, path, body, errorMessage2) {
-  return request(config, designtimeUrl(config, path), { method: "POST", body: JSON.stringify(body ?? {}) }, errorMessage2);
+async function designtimePost(config, path2, body, errorMessage2) {
+  return request(config, designtimeUrl(config, path2), { method: "POST", body: JSON.stringify(body ?? {}) }, errorMessage2);
 }
-async function designtimePut(config, path, body, errorMessage2) {
-  return request(config, designtimeUrl(config, path), { method: "PUT", body: JSON.stringify(body ?? {}) }, errorMessage2);
+async function designtimePut(config, path2, body, errorMessage2) {
+  return request(config, designtimeUrl(config, path2), { method: "PUT", body: JSON.stringify(body ?? {}) }, errorMessage2);
 }
-async function designtimePatch(config, path, body, errorMessage2) {
-  return request(config, designtimeUrl(config, path), { method: "PATCH", body: JSON.stringify(body ?? {}) }, errorMessage2);
+async function designtimePatch(config, path2, body, errorMessage2) {
+  return request(config, designtimeUrl(config, path2), { method: "PATCH", body: JSON.stringify(body ?? {}) }, errorMessage2);
 }
-async function designtimeDelete(config, path, errorMessage2) {
-  return request(config, designtimeUrl(config, path), { method: "DELETE" }, errorMessage2);
+async function designtimeDelete(config, path2, errorMessage2) {
+  return request(config, designtimeUrl(config, path2), { method: "DELETE" }, errorMessage2);
 }
-async function designtimeUploadMultipart(config, path, formData, errorMessage2) {
-  const url = designtimeUrl(config, path);
+async function designtimeUploadMultipart(config, path2, formData, errorMessage2) {
+  const url = designtimeUrl(config, path2);
   const response = await fetch(url, {
     method: "POST",
     headers: baseHeaders(config),
@@ -6159,8 +7281,8 @@ async function designtimeUploadMultipart(config, path, formData, errorMessage2)
   }
   return await response.json();
 }
-async function designtimeDownloadBinary(config, path, errorMessage2) {
-  const url = designtimeUrl(config, path);
+async function designtimeDownloadBinary(config, path2, errorMessage2) {
+  const url = designtimeUrl(config, path2);
   const response = await fetch(url, {
     method: "GET",
     headers: baseHeaders(config)
@@ -6543,7 +7665,7 @@ var DATA_TYPES_DELETE_EXAMPLES = [
 var registerDataTypesCommand = (program2) => {
   const dataTypes = program2.command("data-types").description("Manage data types (entity_defs) — the reusable type definitions fields reference via field_type_id");
   dataTypes.command("add").description("Create a new data type in the project").argument("<project-name>", "Project name").requiredOption("--name <name>", "Data type name").requiredOption("--kind <kind>", "Underlying data type kind: text, date, money, number, boolean, choice").requiredOption("--instructions <text>", "Instructions describing what this type represents and where its values appear").option("--input-value <mode>", "Whether the value appears verbatim in the document (exact-match) or is inferred/computed (inferred). Required when --kind is text or choice; forbidden for date, money, number, and boolean (those kinds don't have this property — matches the IXP UI's radio visibility).").option("--choices <json>", 'Required when --kind choice. JSON array of choices: [{"value":"<canonical>","alternates":["<alt1>","<alt2>",...]}]. `value` (required) is the canonical display name (model output). `alternates` (optional, defaults to []) are alternate spellings the model maps to `value` — omit or set to [] when the canonical value is the only matched form.').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DATA_TYPES_ADD_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const choices = options.choices ? parseChoicesJson(options.choices) : undefined;
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -6571,7 +7693,7 @@ var registerDataTypesCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   dataTypes.command("update-instructions").description("Replace the instructions on an existing data type").argument("<project-name>", "Project name").requiredOption("--name <name>", "Data type name").requiredOption("--instructions <text>", "New instructions text (replaces the existing instructions)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DATA_TYPES_UPDATE_INSTRUCTIONS_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6592,7 +7714,7 @@ var registerDataTypesCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   dataTypes.command("rename").description("Rename a data type. Existing field references stay intact.").argument("<project-name>", "Project name").requiredOption("--name <name>", "Current data type name").requiredOption("--new-name <name>", "New data type name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DATA_TYPES_RENAME_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6615,7 +7737,7 @@ var registerDataTypesCommand = (program2) => {
   dataTypes.command("delete").description("Delete a data type. IRREVERSIBLE: any field referencing it via field_type_id will break.").argument("<project-name>", "Project name").requiredOption("--name <name>", "Data type name to delete").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(DATA_TYPES_DELETE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
     if (!requireConfirmation(options, `delete data type '${options.name}'`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6718,7 +7840,7 @@ var DEPLOYMENTS_LIST_EXAMPLES = [
 var registerDeploymentsCommand = (program2) => {
   const deployments = program2.command("deployments").description("Manage IXP deployments — deploy trained model versions to Orchestrator folders, move a deployment to another version, and inspect the taxonomy pinned to a version");
   deployments.command("create").description("Deploy a trained model version to an Orchestrator folder, making it callable at runtime by activities and Maestro Flow. Only ever adds a deployment — moving an existing one is `deployments upgrade`.").argument("<project-name>", "Project name").requiredOption("--version <number>", "Trained model version to deploy (non-negative integer). Get available versions from `uip ixp projects list-models <project-name> --output json`.", (raw) => parseBoundedInt(raw, "--version", { min: 0, max: 1e6 })).requiredOption("--folder-key <guid>", "Orchestrator folder key (GUID) to deploy into. Get it from `uip or folders list --output json`.").option("--title <title>", "Title to deploy under (defaults to the project name minus its '-ixp' suffix). Comes back verbatim as DeploymentTitle; the backend slugs and suffixes it into the name the runtime resolves, returned as DeploymentName.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DEPLOYMENTS_CREATE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, deployment] = await catchError2((async () => {
+    const [err, deployment] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6740,7 +7862,7 @@ var registerDeploymentsCommand = (program2) => {
     });
   });
   deployments.command("upgrade").description("Move an existing deployment to another trained model version, changing which version every runtime caller of that folder and name gets").argument("<project-name>", "Project name").argument("<deployment-name>", "Deployment to move, addressed by the name the runtime resolves — the DeploymentName field of `uip ixp deployments list <project-name> --output json`, not the title it was created under.").requiredOption("--version <number>", "Trained model version to move the deployment to (non-negative integer). Get available versions from `uip ixp projects list-models <project-name> --output json`.", (raw) => parseBoundedInt(raw, "--version", { min: 0, max: 1e6 })).requiredOption("--folder-key <guid>", "Orchestrator folder key (GUID) hosting the deployment. The same name can be deployed in several folders, so the folder is part of the identity.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DEPLOYMENTS_UPGRADE_EXAMPLES).trackedAction(processContext, async (projectName, deploymentName, options) => {
-    const [err, deployment] = await catchError2((async () => {
+    const [err, deployment] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6761,7 +7883,7 @@ var registerDeploymentsCommand = (program2) => {
     });
   });
   deployments.command("list").description("List the project's model deployments, across every version and folder it has been deployed to").argument("<project-name>", "Project name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DEPLOYMENTS_LIST_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6779,7 +7901,7 @@ var registerDeploymentsCommand = (program2) => {
     });
   });
   deployments.command("get-taxonomy").description("Get the project taxonomy (data types + field groups) at a specific trained model version").argument("<project-name>", "Project name").requiredOption("--version <number>", "Trained model version (non-negative integer). Get available versions from `uip ixp projects list-models <project-name> --output json`.", (raw) => parseBoundedInt(raw, "--version", { min: 0, max: 1e6 })).addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DEPLOYMENTS_GET_TAXONOMY_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, taxonomy] = await catchError2((async () => {
+    const [err, taxonomy] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6845,8 +7967,8 @@ function applyDetectedExtension(targetPath, detectedExt) {
   return targetPath + detectedExt;
 }
 function defaultDownloadPath() {
-  const fs = getFileSystem();
-  return fs.path.join(fs.env.tmpdir(), "ixp_document");
+  const fs2 = getFileSystem();
+  return fs2.path.join(fs2.env.tmpdir(), "ixp_document");
 }
 var DOCUMENTS_LIST_EXAMPLES = [
   {
@@ -6932,7 +8054,7 @@ var DOCUMENTS_DELETE_EXAMPLES = [
 var registerDocumentsCommand = (program2) => {
   const document = program2.command("documents").description("Read IXP document content");
   document.command("list").description("List all documents in a project").argument("<project-name>", "Project name").option("-l, --limit <number>", "Number of items to return (1-10000)", parseLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Number of items to skip (0-1000000)", parseOffset, 0).addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DOCUMENTS_LIST_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, page] = await catchError2((async () => {
+    const [err, page] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -6953,16 +8075,16 @@ var registerDocumentsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   document.command("download").description("Download the original document file (PDF/PNG/JPG/etc.) for viewing").argument("<project-name>", "Project name").argument("<document-id>", "Document ID").option("-o, --output <path>", "Output file path (extension auto-corrected to match content type)", defaultDownloadPath()).addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DOCUMENTS_DOWNLOAD_EXAMPLES).trackedAction(processContext, async (projectName, documentUid, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
       const { buffer, contentType } = await downloadDocument(config, projectName, documentUid);
       const bytes = new Uint8Array(buffer);
       const detectedExt = extensionForContentType(contentType);
-      const fs = getFileSystem();
+      const fs2 = getFileSystem();
       const finalPath = applyDetectedExtension(options.output, detectedExt);
-      await fs.writeFile(finalPath, bytes);
+      await fs2.writeFile(finalPath, bytes);
       return {
         path: finalPath,
         contentType,
@@ -6985,18 +8107,18 @@ var registerDocumentsCommand = (program2) => {
     });
   });
   document.command("upload").description("Upload a document file to an existing project").argument("<project-name>", "Project name").argument("<file>", "Path to the document file to upload").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(DOCUMENTS_UPLOAD_EXAMPLES).trackedAction(processContext, async (projectName, file, options) => {
-    const [err, response] = await catchError2((async () => {
-      const fs = getFileSystem();
-      const resolvedPath = fs.path.resolve(file);
-      const filename = fs.path.basename(resolvedPath);
+    const [err, response] = await catchError((async () => {
+      const fs2 = getFileSystem();
+      const resolvedPath = fs2.path.resolve(file);
+      const filename = fs2.path.basename(resolvedPath);
       const ext = getExtension(filename);
       if (!SUPPORTED_DOCUMENT_EXTENSIONS.has(ext)) {
         throw new Error(`Unsupported file type "${ext || "(none)"}". Supported: ${[...SUPPORTED_DOCUMENT_EXTENSIONS].join(", ")}`);
       }
-      if (!await fs.exists(resolvedPath)) {
+      if (!await fs2.exists(resolvedPath)) {
         throw new Error(`File not found: ${resolvedPath}`);
       }
-      const fileBuffer = await fs.readFile(resolvedPath);
+      const fileBuffer = await fs2.readFile(resolvedPath);
       if (!fileBuffer) {
         throw new Error(`Failed to read file: ${resolvedPath}`);
       }
@@ -7020,7 +8142,7 @@ var registerDocumentsCommand = (program2) => {
   document.command("delete").description("Delete a document from a project").argument("<project-name>", "Project name").argument("<document-id>", "Document ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(DOCUMENTS_DELETE_EXAMPLES).trackedAction(processContext, async (projectName, documentUid, options) => {
     if (!requireConfirmation(options, `delete document '${documentUid}'`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7116,7 +8238,7 @@ var FIELDS_UPDATE_PROMPTS_EXAMPLES = [
 var registerFieldsCommand = (program2) => {
   const fields = program2.command("fields").description("Edit fields within a project's field groups (label_defs)");
   fields.command("add").description("Add a new field to a field group").argument("<project-name>", "Project name").requiredOption("--group <name>", "Field group (label_def) name").requiredOption("--field <name>", "New field name").requiredOption("--type <type-name>", "Field type — name of an entity_def in the project's taxonomy").requiredOption("--instructions <text>", "Instructions for the new field — describes what to extract and where to find it").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(FIELDS_ADD_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7140,7 +8262,7 @@ var registerFieldsCommand = (program2) => {
   fields.command("delete").description("Delete a field from a field group").argument("<project-name>", "Project name").requiredOption("--group <name>", "Field group (label_def) name").requiredOption("--field <name>", "Field name to delete").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(FIELDS_DELETE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
     if (!requireConfirmation(options, `delete field '${options.field}'`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7158,7 +8280,7 @@ var registerFieldsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   fields.command("rename").description("Rename a field within a field group").argument("<project-name>", "Project name").requiredOption("--group <name>", "Field group (label_def) name").requiredOption("--field <name>", "Current field name").requiredOption("--new-name <name>", "New field name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(FIELDS_RENAME_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7178,7 +8300,7 @@ var registerFieldsCommand = (program2) => {
   fields.command("change-type").description("Change a field's type. IRREVERSIBLE: existing annotations for this field are deleted.").argument("<project-name>", "Project name").requiredOption("--group <name>", "Field group (label_def) name").requiredOption("--field <name>", "Field name").requiredOption("--type <type-name>", "New field type — name of an entity_def in the project's taxonomy").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(FIELDS_CHANGE_TYPE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
     if (!requireConfirmation(options, `change the type of field '${options.field}' (deletes its annotations)`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7196,7 +8318,7 @@ var registerFieldsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   fields.command("update-prompts").description("Bulk-update per-field extraction instructions. Match by moon_form field name; existing definitions preserved.").argument("<project-name>", "Project name").requiredOption("--updates <json>", 'JSON array of per-field instruction updates: [{"name":"Invoice Number","instructions":"..."}]. Match by moon_form field name.').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(FIELDS_UPDATE_PROMPTS_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const rawUpdates = JSON.parse(options.updates);
       if (!Array.isArray(rawUpdates)) {
         throw new Error('--updates must be a JSON array, e.g. [{"name":"Invoice Number","instructions":"..."}]');
@@ -7340,7 +8462,7 @@ var GROUPS_UPDATE_PROMPTS_EXAMPLES = [
 var registerGroupsCommand = (program2) => {
   const groups = program2.command("groups").description("Manage field groups (label_defs) — the document type containers for fields");
   groups.command("add").description("Create a new field group with instructions and at least one field").argument("<project-name>", "Project name").requiredOption("--name <name>", "New field group name").requiredOption("--instructions <text>", "Instructions for the group — describes what kind of document/section it covers").requiredOption("--fields <json>", 'JSON array of fields to create in the group (at least one): [{"name":"...","type":"<type-name>","instructions":"..."}]. `type` is the name of an entity_def in the project taxonomy.').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(GROUPS_ADD_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const fields = parseFieldsJson(options.fields);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -7366,7 +8488,7 @@ var registerGroupsCommand = (program2) => {
   groups.command("delete").description("Delete a field group. IRREVERSIBLE: all annotations on all fields in the group are deleted.").argument("<project-name>", "Project name").requiredOption("--name <name>", "Field group name to delete").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(GROUPS_DELETE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
     if (!requireConfirmation(options, `delete group '${options.name}'`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7384,7 +8506,7 @@ var registerGroupsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   groups.command("rename").description("Rename a field group. Preserves all fields and annotations.").argument("<project-name>", "Project name").requiredOption("--name <name>", "Current field group name").requiredOption("--new-name <name>", "New field group name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(GROUPS_RENAME_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7404,7 +8526,7 @@ var registerGroupsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   groups.command("update-prompts").description("Bulk-update field group (label_def) extraction instructions. Match by group name; existing fields preserved.").argument("<project-name>", "Project name").requiredOption("--updates <json>", 'JSON array of field group instruction updates: [{"name":"Invoice","instructions":"..."}]. Match by label_def name.').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(GROUPS_UPDATE_PROMPTS_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const updates = parseUpdatesJson(options.updates);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -7850,7 +8972,7 @@ var registerLabellingsCommand = (program2) => {
     if (!documentUid) {
       getOutputSink().writeErr(PROJECT_WIDE_DEPRECATION_WARNING);
     }
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       validateConfirmMode(documentUid, options);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -7891,7 +9013,7 @@ var registerLabellingsCommand = (program2) => {
     });
   });
   labelling.command("unconfirm").description("Remove confirmations from a document — the targeted fields go back to un-annotated state. Use to roll back an earlier confirm or mark-missing when you realize it was a mistake. Every other annotation on the document is carried forward. With --fields alone, each field_id is unconfirmed across every occurrence it appears in. For a repeatable field group, narrow with --group: alone it unconfirms every occurrence; add --occurrence to roll back ONE occurrence (the ergonomic single-line form); or use --updates to roll back SEVERAL occurrences in one atomic call. Mirrors `confirm`'s targeting flags.").argument("<project-name>", "Project name").argument("<document-id>", "Document ID").option("-f, --fields <field-ids>", "Comma-separated field IDs to unconfirm. Without --group, unconfirms each field_id across every occurrence it appears in. With --group + --occurrence, limits to that specific occurrence; omit it to unconfirm every annotated field in the targeted occurrence(s).").option("--group <name>", 'Target field group (label_def). Must be the FULL label path exactly as shown in the "Name" field of `get-predictions` (e.g. "Invoice > Line Items"), not just the leaf name. On its own, unconfirms every occurrence of the group. Add --occurrence to target a single occurrence, or --updates to batch specific occurrences in one call. Combine with --fields to limit to specific fields within the group.').option("--occurrence <index>", "Single-occurrence form: 0-based index of ONE occurrence within --group to unconfirm. Use --fields to limit to specific fields in that occurrence; omit --fields to unconfirm every annotated field there. Requires --group. Mutually exclusive with --updates.").option("--updates <json>", 'Batched form: unconfirm SEVERAL occurrences of --group in one atomic call. JSON array of {"occurrence":<0-based-index>,"fields"?:["<field_id>",...]}. Per entry: omit "fields" to unconfirm every annotated field in that occurrence, or list specific ones. Occurrences not listed are left as-is. Mutually exclusive with --fields and --occurrence.').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(LABELLINGS_UNCONFIRM_EXAMPLES).trackedAction(processContext, async (projectName, documentUid, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       validateUnconfirmMode(options);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -7914,7 +9036,7 @@ var registerLabellingsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   labelling.command("mark-missing").description("Mark fields as missing in a document — the field is annotated as having no value and no location. Use when the field is genuinely absent from the document.").argument("<project-name>", "Project name").argument("<document-id>", "Document ID").requiredOption("-f, --fields <field-ids>", "Comma-separated field IDs to mark as missing").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(LABELLINGS_MARK_MISSING_EXAMPLES).trackedAction(processContext, async (projectName, documentUid, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -7943,7 +9065,7 @@ var registerLabellingsCommand = (program2) => {
     if (!documentUid) {
       getOutputSink().writeErr(PROJECT_WIDE_DEPRECATION_WARNING);
     }
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8009,7 +9131,7 @@ function parseMetricsModelVersion(raw) {
   return trimmed;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function isCreatedProjectPropagationError(error) {
   const message = error.message;
@@ -8024,7 +9146,7 @@ async function waitForCreatedProjectReady(config, projectName, waitForUploadSurf
   let lastError = new Error("Project readiness check failed without an error.");
   do {
     if (!projectRead) {
-      const [projectErr, fetched] = await catchError2(getProject(config, projectName));
+      const [projectErr, fetched] = await catchError(getProject(config, projectName));
       if (projectErr) {
         lastError = projectErr;
       } else {
@@ -8036,11 +9158,11 @@ async function waitForCreatedProjectReady(config, projectName, waitForUploadSurf
       if (!waitForUploadSurfaces) {
         return project;
       }
-      const [taxonomyErr] = await catchError2(getProjectTaxonomy(config, projectName));
+      const [taxonomyErr] = await catchError(getProjectTaxonomy(config, projectName));
       if (taxonomyErr) {
         lastError = taxonomyErr;
       } else {
-        const [documentsErr] = await catchError2(listDocuments(config, projectName, { limit: 1 }));
+        const [documentsErr] = await catchError(listDocuments(config, projectName, { limit: 1 }));
         if (!documentsErr) {
           return project;
         }
@@ -8061,7 +9183,7 @@ async function waitForCreatedProjectReady(config, projectName, waitForUploadSurf
 }
 async function uploadCreatedProjectDocument(config, projectName, blob, filename) {
   for (let attempt = 1;; attempt++) {
-    const [uploadErr, uploadResult] = await catchError2(uploadDocument(config, projectName, blob, filename));
+    const [uploadErr, uploadResult] = await catchError(uploadDocument(config, projectName, blob, filename));
     if (!uploadErr) {
       return uploadResult;
     }
@@ -8381,7 +9503,7 @@ var PROJECTS_IMPORT_TAXONOMY_EXAMPLES = [
 var registerProjectsCommand = (program2) => {
   const project = program2.command("projects").description("Manage IXP training projects");
   project.command("list").description("List all IXP training projects").option("-l, --limit <number>", "Number of items to return (1-10000)", parseLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Number of items to skip (0-1000000)", parseOffset, 0).addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
-    const [err, page] = await catchError2((async () => {
+    const [err, page] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8402,7 +9524,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("get").description("Get an IXP training project by name").argument("<project-name>", "Project name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_GET_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, p] = await catchError2((async () => {
+    const [err, p] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8422,7 +9544,7 @@ var registerProjectsCommand = (program2) => {
   project.command("delete").description("Permanently delete a project — its documents, taxonomy, and trained models. Irreversible; requires --yes.").argument("<project-name>", "Project name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(PROJECTS_DELETE_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
     if (!requireConfirmation(options, `delete project '${projectName}'`))
       return;
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8440,7 +9562,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("update-title").description("Update the display title of a project").argument("<project-name>", "Project name").argument("<new-title>", "New display title").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_UPDATE_TITLE_EXAMPLES).trackedAction(processContext, async (projectName, newTitle, options) => {
-    const [err, p] = await catchError2((async () => {
+    const [err, p] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8458,7 +9580,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("update-prompt").description("Update the project's overall extraction instructions — the taxonomy-wide prompt that gives the model context relevant across every field group. Matches the IXP UI's 'Overall extraction instructions' field on the Manage Taxonomy page. Distinct from each field group's own prompt (see `groups update-prompts`) and per-field prompts (see `fields update-prompts`).").argument("<project-name>", "Project name").requiredOption("--prompt <text>", "New overall extraction instructions. Replaces the existing value.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_UPDATE_PROMPT_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8476,7 +9598,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("get-taxonomy").description("Export the project's raw IXP taxonomy artifact (data types + field groups). This is an IXP-internal format intended for re-import into another project (see `import-taxonomy`), not a curated, human-readable view.").argument("<project-name>", "Project name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_GET_TAXONOMY_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, taxonomy] = await catchError2((async () => {
+    const [err, taxonomy] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8494,7 +9616,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("configure-model").description("Configure the extraction model settings for a project").argument("<project-name>", "Project name").option("--model <version>", "Extraction model name, validated server-side (e.g. gemini_2_5_flash, gemini_2_5_pro, gpt_4o_2024_05_13)").option("--preprocessing <type>", "Intelligent pre-processing: none, table_mini, table").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_CONFIGURE_MODEL_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, response] = await catchError2((async () => {
+    const [err, response] = await catchError((async () => {
       if (options.model === undefined && options.preprocessing === undefined) {
         throw new Error("Nothing to configure. Pass --model and/or --preprocessing.");
       }
@@ -8521,7 +9643,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("get-metrics").description("Get validation metrics for an IXP project").argument("<project-name>", "Project name").option("-m, --model-version <version>", "Model version (default: latest)", "latest").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_GET_METRICS_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, metrics] = await catchError2((async () => {
+    const [err, metrics] = await catchError((async () => {
       const version = parseMetricsModelVersion(options.modelVersion);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -8540,7 +9662,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("publish").description("Publish a model version, optionally tagging it as live or staging").argument("<project-name>", "Project name").option("-m, --model-version <version>", "Model version to publish (default: latest)").option("--tag <live|staging>", 'Optionally tag the published version. Allowed values: "live" or "staging".').option("-d, --description <text>", "Description for the published version (an empty string clears it)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_PUBLISH_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       if (options.tag !== undefined && !IXP_MODEL_TAGS.includes(options.tag)) {
         throw new Error(`Invalid --tag "${options.tag}". Allowed values: ${IXP_MODEL_TAGS.join(", ")}.`);
       }
@@ -8558,6 +9680,13 @@ var registerProjectsCommand = (program2) => {
       processContext.exit(1);
       return;
     }
+    trackShipSucceeded({
+      ship_kind: "publish",
+      target: options.tag ? `ixp_model_${options.tag}` : "ixp_model_untagged",
+      project_type: "ixp_model",
+      command_name: "uip.ixp.projects.publish",
+      artifact_correlation_key: projectName
+    });
     OutputFormatter.success({
       Result: "Success",
       Code: "IxpProjectsPublish",
@@ -8565,7 +9694,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("unpublish").description("Unpublish a model version. The version stays trained and listable; it is only removed from the published set.").argument("<project-name>", "Project name").requiredOption("-m, --model-version <version>", "Model version to unpublish (a non-negative integer)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_UNPUBLISH_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       const targetVersion = parseModelVersion(options.modelVersion);
       const config = await createIxpConfig({
         tenant: options.tenant
@@ -8584,7 +9713,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("untag").description("Remove the tag from a model version. The version stays trained and published; only its tag pointer is cleared.").argument("<project-name>", "Project name").requiredOption("--tag <live|staging>", 'Tag to remove (by name). Allowed values: "live" or "staging".').addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_UNTAG_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, result] = await catchError2((async () => {
+    const [err, result] = await catchError((async () => {
       if (!IXP_MODEL_TAGS.includes(options.tag)) {
         throw new Error(`Invalid --tag "${options.tag}". Allowed values: ${IXP_MODEL_TAGS.join(", ")}.`);
       }
@@ -8605,7 +9734,7 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("list-models").description("List all model versions and tags for a project").argument("<project-name>", "Project name").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_LIST_MODELS_EXAMPLES).trackedAction(processContext, async (projectName, options) => {
-    const [err, data] = await catchError2((async () => {
+    const [err, data] = await catchError((async () => {
       const config = await createIxpConfig({
         tenant: options.tenant
       });
@@ -8623,18 +9752,18 @@ var registerProjectsCommand = (program2) => {
     }, { preserveDataKeys: true });
   });
   project.command("create").description("Create an IXP project. Given a folder of documents, uploads them and suggests a taxonomy; without a folder, creates an empty project").argument("<name>", "Project name").argument("[folder-path]", "Path to folder containing documents; omit to create an empty project").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-d, --description <text>", "Description of what to extract from the documents").option("--skip-taxonomy", "Create project and upload docs without suggesting a taxonomy").examples(PROJECTS_CREATE_EXAMPLES).trackedAction(processContext, async (name, folder, options) => {
-    const [err, result] = await catchError2((async () => {
-      const fs = getFileSystem();
+    const [err, result] = await catchError((async () => {
+      const fs2 = getFileSystem();
       const config = await createIxpConfig({
         tenant: options.tenant
       });
       let allFiles = [];
       if (folder !== undefined) {
-        const resolvedFolder = fs.path.resolve(folder);
-        if (!await fs.exists(resolvedFolder)) {
+        const resolvedFolder = fs2.path.resolve(folder);
+        if (!await fs2.exists(resolvedFolder)) {
           throw new Error(`Folder not found: ${resolvedFolder}`);
         }
-        allFiles = (await fs.readdir(resolvedFolder)).filter((f) => SUPPORTED_DOCUMENT_EXTENSIONS.has(getExtension(f))).map((f) => fs.path.join(resolvedFolder, f));
+        allFiles = (await fs2.readdir(resolvedFolder)).filter((f) => SUPPORTED_DOCUMENT_EXTENSIONS.has(getExtension(f))).map((f) => fs2.path.join(resolvedFolder, f));
         if (allFiles.length === 0) {
           throw new Error(`No supported documents found in ${resolvedFolder}. Supported: ${[...SUPPORTED_DOCUMENT_EXTENSIONS].join(", ")}`);
         }
@@ -8658,9 +9787,9 @@ var registerProjectsCommand = (program2) => {
       const attachmentRefs = [];
       const failedUploads = [];
       for (const filePath of allFiles) {
-        const filename = fs.path.basename(filePath);
-        const [uploadErr, uploadResult] = await catchError2((async () => {
-          const fileBuffer = await fs.readFile(filePath);
+        const filename = fs2.path.basename(filePath);
+        const [uploadErr, uploadResult] = await catchError((async () => {
+          const fileBuffer = await fs2.readFile(filePath);
           if (!fileBuffer) {
             throw new Error(`Failed to read file: ${filePath}`);
           }
@@ -8702,7 +9831,7 @@ var registerProjectsCommand = (program2) => {
       let taxonomy;
       const lastAttemptErrors = [];
       for (let attempt = 1;attempt <= 3; attempt++) {
-        const [err2, t] = await catchError2((async () => {
+        const [err2, t] = await catchError((async () => {
           const taxonomyResponse = await suggestTaxonomy(config, projectName, options.description || "", taxonomyDocs);
           await importTaxonomy(config, projectName, taxonomyResponse.taxonomy);
           return taxonomyResponse.taxonomy;
@@ -8775,16 +9904,16 @@ var registerProjectsCommand = (program2) => {
     }
   });
   project.command("import-taxonomy").description("Import a taxonomy from a local JSON file into an existing project").argument("<project-name>", "Project name").argument("<file>", "Path to taxonomy JSON file").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(PROJECTS_IMPORT_TAXONOMY_EXAMPLES).trackedAction(processContext, async (projectName, file, options) => {
-    const [err, result] = await catchError2((async () => {
-      const fs = getFileSystem();
+    const [err, result] = await catchError((async () => {
+      const fs2 = getFileSystem();
       const config = await createIxpConfig({
         tenant: options.tenant
       });
-      const resolvedFile = fs.path.resolve(file);
-      if (!await fs.exists(resolvedFile)) {
+      const resolvedFile = fs2.path.resolve(file);
+      if (!await fs2.exists(resolvedFile)) {
         throw new Error(`Taxonomy file not found: ${resolvedFile}`);
       }
-      const contents = await fs.readFile(resolvedFile, "utf-8");
+      const contents = await fs2.readFile(resolvedFile, "utf-8");
       if (contents === null) {
         throw new Error(`Failed to read taxonomy file: ${resolvedFile}`);
       }
@@ -8843,4 +9972,4 @@ var registerCommands = async (program2) => {
 
 export { package_default, Command, metadata, registerCommands };
 
-//# debugId=F34ED4C1536D1D8464756E2164756E21
+//# debugId=51E7603847BA1B1464756E2164756E21