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

package/dist/{tool-hmgg9vyj.js → tool-6cra7bw3.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/pm-tool",
   license: "MIT",
-  version: "1.201.0",
+  version: "1.202.0-preview.136",
   description: "Process Mining — process apps, transformations, and data ingestion.",
   private: false,
   repository: {
@@ -2154,81 +2142,402 @@ var package_default = {
   }
 };
 
-// ../common/src/catch-error.ts
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
-}
-function catchError2(fnOrPromise) {
-  if (isPromiseLike(fnOrPromise)) {
-    return settlePromiseLike(fnOrPromise);
+// ../filesystem/src/node.ts
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+
+class NodeFileSystem {
+  path = {
+    join: path.join,
+    resolve: path.resolve,
+    relative: path.relative,
+    dirname: path.dirname,
+    isAbsolute: path.isAbsolute,
+    basename: path.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os.homedir,
+    tmpdir: os.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      const { default: open } = await import("./index-sby22td6.js");
+      await open(url);
+    }
+  };
+  async readFile(path2, options) {
+    try {
+      if (options) {
+        return await fs.readFile(path2, "utf-8");
+      }
+      return await fs.readFile(path2);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
   }
-  try {
-    const result = fnOrPromise();
-    if (isPromiseLike(result)) {
-      return settlePromiseLike(result);
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (dir) {
+      await fs.mkdir(dir, { recursive: true });
     }
-    return [undefined, result];
-  } catch (error) {
-    return [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ];
+    await fs.writeFile(filePath, data);
+  }
+  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;
   }
-}
-function settlePromiseLike(thenable) {
-  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
-    error instanceof Error ? error : new Error(String(error)),
-    undefined
-  ]);
 }
 
-// ../common/src/error-handler.ts
-var NETWORK_ERROR_CODES = new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EAI_AGAIN",
-  "ETIMEDOUT",
-  "EPIPE",
-  "EHOSTUNREACH",
-  "ENETUNREACH",
-  "EAI_FAIL"
+// ../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 TLS_ERROR_CODES = new Set([
-  "SELF_SIGNED_CERT_IN_CHAIN",
-  "DEPTH_ZERO_SELF_SIGNED_CERT",
-  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
-  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
-  "UNABLE_TO_GET_ISSUER_CERT",
-  "CERT_HAS_EXPIRED",
-  "CERT_UNTRUSTED",
-  "ERR_TLS_CERT_ALTNAME_INVALID"
+var SHA256_INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
 ]);
-var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
-var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
-var LOCAL_PERMISSION_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
-// ../../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;
+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/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;
@@ -2259,66 +2568,422 @@ function singleton(ctorOrName) {
   };
 }
 
-// ../common/src/preview.ts
-var previewSlot = singleton("PreviewBuild");
-function isPreviewBuild() {
-  return previewSlot.get(false) ?? false;
+// ../common/src/telemetry/supplied-values.ts
+var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
+function activeEntries() {
+  const existing = suppliedValuesSlot.get();
+  return Array.isArray(existing) ? existing : [];
+}
+var MIN_SCRUBBABLE_LENGTH = 4;
+function recordSuppliedArgumentValues(values) {
+  const flat = [];
+  const push = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        push(item);
+      }
+      return;
+    }
+    if (typeof value === "string" && value.length >= MIN_SCRUBBABLE_LENGTH) {
+      flat.push(value);
+    }
+  };
+  push(values);
+  const entry = { values: flat };
+  suppliedValuesSlot.set([...activeEntries(), entry]);
+  return entry;
 }
-Command.prototype.previewCommand = function(nameAndArgs, opts) {
-  if (isPreviewBuild()) {
-    return this.command(nameAndArgs, opts);
+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 new Command(nameAndArgs.split(/\s+/)[0] ?? nameAndArgs);
-};
+  return [...all].sort((a, b) => b.length - a.length);
+}
 
-// ../common/src/output-context.ts
-function createStorage() {
-  const [error, mod] = catchError2(() => __require("node:async_hooks"));
-  if (error || typeof mod?.AsyncLocalStorage !== "function") {
-    return {
-      getStore: () => {
-        return;
-      },
-      run: (_store, fn) => fn()
-    };
-  }
-  return new mod.AsyncLocalStorage;
+// ../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 storageSingleton = singleton("OutputStorage");
-var sinkSlot = singleton("OutputSink");
-var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
-var CONSOLE_FALLBACK = {
-  writeOut: (str) => process.stdout.write(str),
-  writeErr: (str) => process.stderr.write(str),
-  writeLog: (str) => process.stdout.write(str),
-  capabilities: {
-    isInteractive: false,
-    canReadInput: false,
-    supportsColor: false,
-    outputWidth: 80
+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;
   }
-};
-function getOutputSink() {
-  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
+  return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-
-// ../common/src/logger.ts
-var logFilePathSlot = singleton("logFilePath");
-function setGlobalLogFilePath(path) {
-  logFilePathSlot.set(path);
+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 getGlobalLogFilePath() {
-  return logFilePathSlot.get("");
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${pseudonymize(raw)}`;
+  }
 }
-var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
-
-class SimpleLogger {
-  __brand = "SimpleLogger";
-  level;
-  logFilePath;
-  fileLoggingEnabled;
-  pendingWrites = Promise.resolve();
-  pendingInit = Promise.resolve();
+function redactValueDetectors(value, maxLength = MAX_VALUE_LENGTH) {
+  let out = truncate(value, MAX_SCAN_LENGTH);
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const [core, trailing] = peelTrailingPunctuation(match);
+    return `${redactUrl(core)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(UNC_PATH_PATTERN, (_match, before, path2) => {
+    const [core, trailing] = peelTrailingPunctuation(path2);
+    return `${before}unc#${pseudonymize(core)}${trailing}`;
+  });
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${pseudonymize(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${pseudonymize(match)}`);
+  out = out.replace(HOST_PORT_PATTERN, (match) => {
+    const split = match.lastIndexOf(":");
+    const host = match.slice(0, split);
+    const extension = host.slice(host.lastIndexOf(".") + 1).toLowerCase();
+    if (SOURCE_FILE_EXTENSIONS.has(extension)) {
+      return match;
+    }
+    return `host#${pseudonymize(host)}:${match.slice(split + 1)}`;
+  });
+  out = out.replace(PADDED_BASE64_PATTERN, () => REDACTED);
+  out = out.replace(BASE64_WITH_PLUS_PATTERN, (match) => match.includes("+") ? REDACTED : match);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  return truncate(out, maxLength);
+}
+function redactSpanName(name) {
+  return redactValueDetectors(truncate(name, MAX_SCAN_LENGTH).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`));
+}
+var HTTP_DEPENDENCY_NAME = /^([A-Z]+) (\/.*)$/s;
+function redactHttpDependencyName(name) {
+  const parts = HTTP_DEPENDENCY_NAME.exec(name);
+  if (!parts) {
+    return redactMessage(name);
+  }
+  return `${parts[1]} ${redactMessage(parts[2])}`;
+}
+function redactMessage(value) {
+  let out = collapseJsonBodies(truncate(value, MAX_SCAN_LENGTH)).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`);
+  for (const supplied of getSuppliedArgumentValues()) {
+    out = out.split(supplied).join(REDACTED);
+  }
+  return redactValueDetectors(out);
+}
+var MESSAGE_NAMES = new Set([
+  "message",
+  "errormessage",
+  "errmessage",
+  "error_message",
+  "msg",
+  "detail",
+  "details",
+  "reason",
+  "instructions",
+  "warning"
+]);
+function isFreeFormValue(name, value) {
+  return MESSAGE_NAMES.has(name.toLowerCase()) || /['"{[]/.test(value);
+}
+function redactError(error) {
+  const safe = new Error(redactMessage(error.message ?? ""));
+  safe.name = error.name;
+  safe.stack = typeof error.stack === "string" ? redactStack(error.stack) : undefined;
+  return safe;
+}
+function redactStack(stack) {
+  const bounded = truncate(stack, MAX_STACK_LENGTH);
+  const firstBreak = bounded.indexOf(`
+`);
+  if (firstBreak === -1) {
+    return redactMessage(bounded);
+  }
+  return `${redactMessage(bounded.slice(0, firstBreak))}
+${redactValueDetectors(bounded.slice(firstBreak + 1), MAX_STACK_LENGTH)}`;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return isFreeFormValue(name, value) ? redactMessage(value) : redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+
+// ../common/src/catch-error.ts
+var MAX_SERIALIZED_LENGTH = 500;
+var TRUNCATION_SUFFIX = "…(truncated)";
+var REDACTED2 = "[REDACTED]";
+function cap(text) {
+  return text.length > MAX_SERIALIZED_LENGTH ? `${text.slice(0, MAX_SERIALIZED_LENGTH)}${TRUNCATION_SUFFIX}` : text;
+}
+function omitSensitive(key, value) {
+  return key.length > 0 && isSensitiveName(key) ? REDACTED2 : value;
+}
+function describeThrownValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value);
+  }
+  let message;
+  try {
+    message = value.message;
+  } catch {
+    message = undefined;
+  }
+  if (typeof message === "string" && message.length > 0) {
+    return cap(message);
+  }
+  try {
+    const json = JSON.stringify(value, omitSensitive);
+    if (json !== undefined) {
+      return cap(json);
+    }
+  } catch {}
+  return String(value);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(describeThrownValue(error), { cause: error });
+}
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [toError(error), undefined];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
+}
+
+// ../common/src/error-handler.ts
+var NETWORK_ERROR_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EAI_FAIL"
+]);
+var TLS_ERROR_CODES = new Set([
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_GET_ISSUER_CERT",
+  "CERT_HAS_EXPIRED",
+  "CERT_UNTRUSTED",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
+var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
+var LOCAL_PERMISSION_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
+// ../common/src/exit-code.ts
+function setExitCode(code) {
+  process.exitCode = code;
+}
+
+// ../common/src/output-context.ts
+function createStorage() {
+  const [error, mod] = catchError(() => __require("node:async_hooks"));
+  if (error || typeof mod?.AsyncLocalStorage !== "function") {
+    return {
+      getStore: () => {
+        return;
+      },
+      run: (_store, fn) => fn()
+    };
+  }
+  return new mod.AsyncLocalStorage;
+}
+var storageSingleton = singleton("OutputStorage");
+var sinkSlot = singleton("OutputSink");
+var outputStorage = storageSingleton.getOrInit(createStorage, (v) => ("getStore" in v));
+var CONSOLE_FALLBACK = {
+  writeOut: (str) => process.stdout.write(str),
+  writeErr: (str) => process.stderr.write(str),
+  writeLog: (str) => process.stdout.write(str),
+  capabilities: {
+    isInteractive: false,
+    canReadInput: false,
+    supportsColor: false,
+    outputWidth: 80
+  }
+};
+function getOutputSink() {
+  return outputStorage.getStore() ?? sinkSlot.get() ?? CONSOLE_FALLBACK;
+}
+
+// ../common/src/logger.ts
+var logFilePathSlot = singleton("logFilePath");
+function setGlobalLogFilePath(path2) {
+  logFilePathSlot.set(path2);
+}
+function getGlobalLogFilePath() {
+  return logFilePathSlot.get("");
+}
+var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
+
+class SimpleLogger {
+  __brand = "SimpleLogger";
+  level;
+  logFilePath;
+  fileLoggingEnabled;
+  pendingWrites = Promise.resolve();
+  pendingInit = Promise.resolve();
   constructor() {
     this.level = SimpleLogger.resolveLevel();
     this.logFilePath = "";
@@ -2342,7 +3007,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 */;
     }
@@ -2373,54 +3038,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;
@@ -2435,17 +3095,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;
@@ -2499,12 +3159,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);
     }));
   }
@@ -2759,7 +3419,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"]
   }));
@@ -2782,27 +3442,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
     })));
   }
@@ -3037,165 +3711,37 @@ function resolveTelemetrySession() {
   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);
+  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;
@@ -3215,36 +3761,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;
     }
   }
@@ -3253,8 +3802,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();
@@ -3262,7 +3810,8 @@ class TelemetryService {
     return {
       operationId,
       ...parentId !== undefined ? { parentId } : {},
-      id: this.generateId()
+      id: this.generateId(),
+      startedAt: startSpanClock().startedAt
     };
   }
   inboundParentIdFor(operationId) {
@@ -3273,58 +3822,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;
   }
@@ -3341,6 +3916,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");
 
@@ -3361,6 +4011,9 @@ function getGlobalTelemetryInstance() {
   }
   return;
 }
+function setGlobalTelemetryInstance(instance) {
+  telemetryInstanceSlot.set(instance);
+}
 var _localTelemetryInstance;
 function getTelemetryInstance() {
   const global = getGlobalTelemetryInstance();
@@ -3368,6 +4021,7 @@ function getTelemetryInstance() {
     return global;
   if (!_localTelemetryInstance) {
     _localTelemetryInstance = new TelemetryService(new LoggerTelemetryProvider, new NodeContextStorage);
+    setGlobalTelemetryInstance(_localTelemetryInstance);
   }
   return _localTelemetryInstance;
 }
@@ -3380,6 +4034,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",
@@ -3418,22 +4080,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");
@@ -3498,19 +4144,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 = {};
@@ -3520,7 +4192,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;
@@ -3555,7 +4227,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);
         }
@@ -3566,10 +4238,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 ?? "");
@@ -3583,7 +4256,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()));
@@ -3593,7 +4266,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("");
@@ -3636,14 +4309,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)));
@@ -3651,7 +4324,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;
@@ -3697,6 +4370,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++) {
@@ -3704,7 +4378,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) {
@@ -3848,30 +4522,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
@@ -3947,6 +4627,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:";
@@ -4101,6 +4814,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);
@@ -4108,28 +4872,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 = [];
@@ -4144,7 +4954,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);
@@ -4184,68 +4994,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
@@ -4268,6 +5087,204 @@ var guardInstalledSlot = singleton("ConsoleGuardInstalled");
 var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 // ../common/src/constants.ts
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+// ../common/src/entity-name-rules.ts
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
 // ../common/src/host-global-options.ts
 var HOST_GLOBAL_OPTIONS_WITH_VALUE = [
   "--output",
@@ -4335,6 +5352,40 @@ var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
 // ../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");
@@ -4348,7 +5399,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
@@ -4369,10 +5420,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.`);
@@ -4427,6 +5484,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";
@@ -4438,7 +5500,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: () => {
@@ -4454,9 +5516,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();
 
@@ -4487,8 +5549,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();
@@ -4569,7 +5631,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;
@@ -4653,27 +5715,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);
@@ -4699,8 +5782,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);
@@ -4709,9 +5792,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);
@@ -4722,20 +5805,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 {}
 }
@@ -4756,43 +5839,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);
@@ -4812,7 +5895,7 @@ var defaultLoadModule = async () => {
   if (!hostLoader) {
     return;
   }
-  const [error, mod] = await catchError(() => hostLoader());
+  const [error, mod] = await catchError2(() => hostLoader());
   if (error || !mod) {
     return;
   }
@@ -4838,7 +5921,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;
   }
@@ -4861,7 +5944,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) {
@@ -4888,7 +5971,7 @@ var tryRobotClientFallback = async (options = {}) => {
   } catch {
     return;
   } finally {
-    await catchError(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
+    await catchError2(() => withTimeout(proxy.CloseAsync(), CLOSE_TIMEOUT_MS));
   }
 };
 
@@ -4958,9 +6041,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 };
     }
@@ -4987,9 +6070,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,
@@ -4997,11 +6080,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,
@@ -5009,14 +6092,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" };
   }
@@ -5038,12 +6121,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}`);
   }
@@ -5072,10 +6155,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 {}
@@ -5093,11 +6176,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
@@ -5211,11 +6294,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 });
@@ -5619,6 +6702,7 @@ var TENANT_SELECTION_CODES = new Set([
 ]);
 // src/client.ts
 var PM_API_VERSION = "v38";
+var PMT_API_VERSION = "v6.0";
 async function createPmConfig(tenantOverride) {
   const ctx = await getAuthContext({
     tenant: tenantOverride,
@@ -5633,8 +6717,11 @@ async function createPmConfig(tenantOverride) {
     authToken: ctx.accessToken
   };
 }
-function buildPmUrl(config, path) {
-  return `${config.baseUrl}/${config.organizationName}/${config.tenantName}/processmining_/api/${PM_API_VERSION}${path}`;
+function buildPmUrl(config, path2) {
+  return `${config.baseUrl}/${config.organizationName}/${config.tenantName}/processmining_/api/${PM_API_VERSION}${path2}`;
+}
+function buildPmtUrl(config, path2) {
+  return `${config.baseUrl}/${config.organizationName}/${config.tenantName}/processmining_/api/pmt/${PMT_API_VERSION}${path2}`;
 }
 function buildHeaders(config) {
   return {
@@ -5662,14 +6749,14 @@ async function toApiError(response) {
 function parseJsonBody(text) {
   if (!text)
     return null;
-  const [parseErr, parsed] = catchError2(() => JSON.parse(text));
+  const [parseErr, parsed] = catchError(() => JSON.parse(text));
   if (parseErr) {
     throw new Error(`Failed to parse API response body: ${parseErr.message}`);
   }
   return parsed;
 }
-async function pmRequest(config, method, path, body) {
-  const response = await fetch(buildPmUrl(config, path), {
+async function pmRequest(config, method, path2, body) {
+  const response = await fetch(buildPmUrl(config, path2), {
     method,
     headers: buildHeaders(config),
     body: body === undefined ? undefined : JSON.stringify(body)
@@ -5678,20 +6765,20 @@ async function pmRequest(config, method, path, body) {
     throw await toApiError(response);
   return parseJsonBody(await response.text());
 }
-async function pmGet(config, path) {
-  const result = await pmRequest(config, "GET", path);
+async function pmGet(config, path2) {
+  const result = await pmRequest(config, "GET", path2);
   if (result === null)
     throw new Error("API returned an empty response body");
   return result;
 }
-async function pmPost(config, path, body) {
-  return pmRequest(config, "POST", path, body);
+async function pmPost(config, path2, body) {
+  return pmRequest(config, "POST", path2, body);
 }
-async function pmDelete(config, path) {
-  return pmRequest(config, "DELETE", path);
+async function pmDelete(config, path2, body) {
+  return pmRequest(config, "DELETE", path2, body);
 }
-async function pmGetRaw(config, path) {
-  const response = await fetch(buildPmUrl(config, path), {
+async function pmGetRaw(config, path2) {
+  const response = await fetch(buildPmUrl(config, path2), {
     method: "GET",
     headers: { Authorization: `Bearer ${config.authToken}` }
   });
@@ -5702,8 +6789,8 @@ async function pmGetRaw(config, path) {
     etag: response.headers.get("etag")
   };
 }
-async function pmPutJson(config, path, body, etag) {
-  const response = await fetch(buildPmUrl(config, path), {
+async function pmPutJson(config, path2, body, etag) {
+  const response = await fetch(buildPmUrl(config, path2), {
     method: "PUT",
     headers: {
       Authorization: `Bearer ${config.authToken}`,
@@ -5717,14 +6804,76 @@ async function pmPutJson(config, path, body, etag) {
     throw await toApiError(response);
   return parseJsonBody(await response.text());
 }
-async function pmPutRaw(config, path, content, etag) {
-  return putRaw(config, path, content, { "If-Match": etag });
+var APP_TOKEN_REFRESH_MARGIN_SECONDS = 60;
+var APP_TOKEN_FALLBACK_TTL_SECONDS = 300;
+var appTokenCache = new Map;
+function appTokenCacheKey(config, appId) {
+  return `${config.baseUrl}|${config.organizationName}|${config.tenantName}|${appId}`;
+}
+function readTokenExpirySeconds(token) {
+  const payload = token.split(".")[1];
+  if (!payload)
+    return null;
+  const [err, exp] = catchError(() => {
+    const b64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+    const claims = JSON.parse(atob(padded));
+    return typeof claims.exp === "number" ? claims.exp : null;
+  });
+  return err ? null : exp;
+}
+async function getAppToken(config, appId, forceRefresh = false) {
+  const key = appTokenCacheKey(config, appId);
+  const cached = appTokenCache.get(key);
+  if (!forceRefresh && cached && cached.expiresAtMs > Date.now()) {
+    return cached.token;
+  }
+  appTokenCache.delete(key);
+  const result = await pmGet(config, `/apps/${encodeURIComponent(appId)}/token`);
+  const token = result.accessToken;
+  if (!token) {
+    throw new Error("App token response did not contain an access token");
+  }
+  const expSeconds = readTokenExpirySeconds(token);
+  const ttlSeconds = expSeconds === null ? APP_TOKEN_FALLBACK_TTL_SECONDS : expSeconds - Math.floor(Date.now() / 1000) - APP_TOKEN_REFRESH_MARGIN_SECONDS;
+  if (ttlSeconds > 0) {
+    appTokenCache.set(key, {
+      token,
+      expiresAtMs: Date.now() + ttlSeconds * 1000
+    });
+  }
+  return token;
+}
+async function pmtFetch(config, appId, path2, forceRefresh) {
+  const token = await getAppToken(config, appId, forceRefresh);
+  return fetch(buildPmtUrl(config, path2), {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+}
+async function pmtGet(config, appId, path2) {
+  let response = await pmtFetch(config, appId, path2, false);
+  if (response.status === 401) {
+    response = await pmtFetch(config, appId, path2, true);
+  }
+  if (!response.ok)
+    throw await toApiError(response);
+  const result = parseJsonBody(await response.text());
+  if (result === null)
+    throw new Error("API returned an empty response body");
+  return result;
+}
+async function pmPutRaw(config, path2, content, etag) {
+  return putRaw(config, path2, content, { "If-Match": etag });
 }
-async function pmCreateRaw(config, path, content) {
-  return putRaw(config, path, content);
+async function pmCreateRaw(config, path2, content) {
+  return putRaw(config, path2, content);
 }
-async function putRaw(config, path, content, extraHeaders) {
-  const response = await fetch(buildPmUrl(config, path), {
+async function putRawResponse(config, path2, content, extraHeaders) {
+  const response = await fetch(buildPmUrl(config, path2), {
     method: "PUT",
     headers: {
       Authorization: `Bearer ${config.authToken}`,
@@ -5735,7 +6884,14 @@ async function putRaw(config, path, content, extraHeaders) {
   });
   if (!response.ok)
     throw await toApiError(response);
-  return response.headers.get("etag");
+  return response;
+}
+async function putRaw(config, path2, content, extraHeaders) {
+  return (await putRawResponse(config, path2, content, extraHeaders)).headers.get("etag");
+}
+async function pmPutBinaryJson(config, path2, content) {
+  const response = await putRawResponse(config, path2, content);
+  return parseJsonBody(await response.text());
 }
 
 // src/commands/_shared.ts
@@ -5754,7 +6910,7 @@ function rerunInstructions(command) {
   return "Someone else changed this resource while the command was running, so the write " + `was rejected. Re-run '${command}' — it reads the latest version and re-applies ` + "your change on top of it.";
 }
 async function loadConfigOrExit() {
-  const [configErr, config] = await catchError2(createPmConfig());
+  const [configErr, config] = await catchError(createPmConfig());
   if (configErr) {
     fail(configErr.message, "Run 'uip login' to authenticate first.");
     return null;
@@ -5792,12 +6948,13 @@ async function resolveJsonBody(file, inline, flag = "body") {
   } else {
     throw new Error(`A ${noun} is required: pass --${flag} <json-file> or --${flag}-json <json>.`);
   }
-  const [parseErr, parsed] = catchError2(() => JSON.parse(raw));
+  const [parseErr, parsed] = catchError(() => JSON.parse(raw));
   if (parseErr) {
     throw new Error(`${Noun} is not valid JSON: ${parseErr.message}`);
   }
   return parsed;
 }
+var sanitizeKey = (s) => s.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
 var TERMINAL_STATUSES2 = new Set([
   "SUCCESS",
   "SUCCESS_WITH_WARNINGS",
@@ -5807,7 +6964,7 @@ var TERMINAL_STATUSES2 = new Set([
   "CANCELLED",
   "CANCELED"
 ]);
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var isTerminal = (status) => status !== undefined && status !== "" && TERMINAL_STATUSES2.has(status.toUpperCase());
 var DEFAULT_TIMEOUT_SECONDS = 1800;
 var DEFAULT_POLL_INTERVAL_SECONDS = 5;
@@ -5855,7 +7012,7 @@ async function waitForIngestion(config, appId, stage, options, before = {}) {
 async function collectFailureMessages(config, appId, stage, ingestionId) {
   if (!ingestionId)
     return [];
-  const [err, res] = await catchError2(pmGet(config, `/apps/${appId}/${stage}/logs/${ingestionId}?pageNumber=1&pageSize=200`));
+  const [err, res] = await catchError(pmGet(config, `/apps/${appId}/${stage}/logs/${ingestionId}?pageNumber=1&pageSize=200`));
   if (err)
     return [];
   return errorMessagesFrom(res);
@@ -5914,13 +7071,13 @@ async function waitForBuild(config, appId, options, before = {}) {
   }
 }
 async function collectBuildFailureMessages(config, appId) {
-  const [err, res] = await catchError2(pmGet(config, `/apps/${appId}/dev/transformation/build/logs`));
+  const [err, res] = await catchError(pmGet(config, `/apps/${appId}/dev/transformation/build/logs`));
   if (err)
     return [];
   return errorMessagesFrom(res);
 }
 async function waitAndReportBuild(config, appId, options, code, before = {}) {
-  const [waitErr, result] = await catchError2(waitForBuild(config, appId, options, before));
+  const [waitErr, result] = await catchError(waitForBuild(config, appId, options, before));
   if (waitErr) {
     fail(waitErr.message, `Increase --timeout, or check progress with 'uip pm transformations status ${appId}'.`);
     return;
@@ -5939,7 +7096,7 @@ ${messages.join(`
   });
 }
 async function waitAndReport(config, appId, options, code, noun, before = {}) {
-  const [waitErr, result] = await catchError2(waitForIngestion(config, appId, options.stage, options, before));
+  const [waitErr, result] = await catchError(waitForIngestion(config, appId, options.stage, options, before));
   if (waitErr) {
     fail(waitErr.message, "Increase --timeout, or check progress with 'uip pm apps list'.");
     return;
@@ -5975,7 +7132,7 @@ function registerAppTypesCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(pmGet(config, "/appTypes"));
+    const [apiErr, result] = await catchError(pmGet(config, "/appTypes"));
     if (apiErr) {
       fail(apiErr.message, "Check your authentication and that Process Mining is enabled on this tenant.");
       return;
@@ -5990,7 +7147,7 @@ function registerAppTypesCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(pmGet(config, `/appTypes/${encodeURIComponent(appTypeKey)}/${encodeURIComponent(appTypeVersion)}`));
+    const [apiErr, result] = await catchError(pmGet(config, `/appTypes/${encodeURIComponent(appTypeKey)}/${encodeURIComponent(appTypeVersion)}`));
     if (apiErr) {
       fail(apiErr.message, "Check the app type key and version (uip pm app-types list).");
       return;
@@ -6072,13 +7229,13 @@ function findDashboard(dashboards, selector) {
   const known = dashboards.map((entry) => `${entry.id} (${entry.name})`).join(", ");
   throw new Error(`No dashboard matched '${selector}'. Known dashboards: ${known || "none"}.`);
 }
-async function readJsonFile(path) {
-  const content = await getFileSystem().readFile(path, "utf-8");
+async function readJsonFile(path2) {
+  const content = await getFileSystem().readFile(path2, "utf-8");
   if (content === null)
-    throw new Error(`Local file not found: ${path}`);
-  const [parseErr, parsed] = catchError2(() => JSON.parse(String(content)));
+    throw new Error(`Local file not found: ${path2}`);
+  const [parseErr, parsed] = catchError(() => JSON.parse(String(content)));
   if (parseErr) {
-    throw new Error(`${path} is not valid JSON: ${parseErr.message}`);
+    throw new Error(`${path2} is not valid JSON: ${parseErr.message}`);
   }
   return parsed;
 }
@@ -6128,7 +7285,7 @@ function registerModelDashboardCommands(modelCmd) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(readModel(config, appId, options.stage));
+    const [apiErr, result] = await catchError(readModel(config, appId, options.stage));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list) and your authentication.");
       return;
@@ -6150,14 +7307,14 @@ function registerModelDashboardCommands(modelCmd) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(readModel(config, appId, options.stage));
+    const [apiErr, result] = await catchError(readModel(config, appId, options.stage));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list) and your authentication.");
       return;
     }
     let payload = result.model.view ?? {};
     if (options.dashboard !== undefined) {
-      const [selectErr, selected] = catchError2(() => findDashboard(readDashboards(result.model), options.dashboard));
+      const [selectErr, selected] = catchError(() => findDashboard(readDashboards(result.model), options.dashboard));
       if (selectErr) {
         fail(selectErr.message, `List them with 'uip pm apps model dashboards list ${appId}'.`);
         return;
@@ -6166,7 +7323,7 @@ function registerModelDashboardCommands(modelCmd) {
     }
     const serialized = JSON.stringify(payload, null, 2);
     if (options.destination !== undefined) {
-      const [writeErr] = await catchError2(getFileSystem().writeFile(options.destination, serialized));
+      const [writeErr] = await catchError(getFileSystem().writeFile(options.destination, serialized));
       if (writeErr) {
         fail(writeErr.message, "Check the destination path and that the disk is writable.");
         return;
@@ -6186,7 +7343,7 @@ function registerModelDashboardCommands(modelCmd) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, versions] = await catchError2(writeDashboards(config, appId, options));
+    const [err, versions] = await catchError(writeDashboards(config, appId, options));
     if (err) {
       fail(err.message, isConflictError(err) ? conflictInstructions(`uip pm apps model dashboards get ${appId} --destination <file>`) : "Check the JSON file, and that --etag is the ETag " + `'uip pm apps model dashboards get ${appId}' returns.`);
       return;
@@ -6206,7 +7363,7 @@ function registerModelDashboardCommands(modelCmd) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(readModel(config, appId, options.stage));
+    const [apiErr, result] = await catchError(readModel(config, appId, options.stage));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list) and your authentication.");
       return;
@@ -6339,7 +7496,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(pmGet(config, `/apps?stage=${options.stage}`));
+    const [apiErr, result] = await catchError(pmGet(config, `/apps?stage=${options.stage}`));
     if (apiErr) {
       fail(apiErr.message, "Check your authentication and that Process Mining is enabled on this tenant.");
       return;
@@ -6354,7 +7511,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(pmGet(config, `/apps/${appId}/${options.stage}`));
+    const [apiErr, result] = await catchError(pmGet(config, `/apps/${appId}/${options.stage}`));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list) and your authentication.");
       return;
@@ -6369,7 +7526,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, appId] = await catchError2(createApp(config, name, options));
+    const [err, appId] = await catchError(createApp(config, name, options));
     if (err) {
       fail(err.message, "Check the app type key/version (uip pm app-types list) and the data mapping file.");
       return;
@@ -6386,7 +7543,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err] = await catchError2(pmDelete(config, `/apps/${appId}`));
+    const [err] = await catchError(pmDelete(config, `/apps/${appId}`));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list).");
       return;
@@ -6401,7 +7558,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, result] = await catchError2(publishApp(config, appId));
+    const [err, result] = await catchError(publishApp(config, appId));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list) and that there are dev changes to publish.");
       return;
@@ -6425,7 +7582,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, changes] = await catchError2(readDevChanges(config, appId));
+    const [err, changes] = await catchError(readDevChanges(config, appId));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list).");
       return;
@@ -6446,7 +7603,7 @@ function registerAppsCommand(program2) {
     if (options.sinceVersion !== undefined)
       query.push(`sinceVersion=${encodeURIComponent(options.sinceVersion)}`);
     const suffix = query.length === 0 ? "" : `?${query.join("&")}`;
-    const [apiErr, result] = await catchError2(pmGet(config, `/apps/${appId}/publications${suffix}`));
+    const [apiErr, result] = await catchError(pmGet(config, `/apps/${appId}/publications${suffix}`));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list).");
       return;
@@ -6468,7 +7625,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, added] = await catchError2(addModelTables(config, appId, options));
+    const [err, added] = await catchError(addModelTables(config, appId, options));
     if (err) {
       fail(err.message, isConflictError(err) ? rerunInstructions(`uip pm apps data-model add-table ${appId} --file ${options.file}`) : "Check the app id and the --file JSON shape.");
       return;
@@ -6495,7 +7652,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, versions] = await catchError2(updateSemanticModel(config, appId, options));
+    const [err, versions] = await catchError(updateSemanticModel(config, appId, options));
     if (err) {
       fail(err.message, isConflictError(err) ? conflictInstructions(`uip pm apps model get ${appId} --destination <file>`) : modelWriteHint(err));
       return;
@@ -6515,7 +7672,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, file] = await catchError2(pmGetRaw(config, `/apps/${appId}/${options.stage}/model`));
+    const [err, file] = await catchError(pmGetRaw(config, `/apps/${appId}/${options.stage}/model`));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list).");
       return;
@@ -6535,12 +7692,12 @@ function registerAppsCommand(program2) {
       return;
     }
     const hasExpression = options.expression !== undefined;
-    const [parseErr, expression] = hasExpression ? await catchError2(readExpressionArg(options.expression)) : [null, undefined];
+    const [parseErr, expression] = hasExpression ? await catchError(readExpressionArg(options.expression)) : [null, undefined];
     if (parseErr) {
       fail(parseErr.message, "--expression must be a JSON expression node (inline or @file.json).");
       return;
     }
-    const [err, outcome] = await catchError2(editSemanticModel(config, appId, (model) => upsertModelField(model, fieldId, {
+    const [err, outcome] = await catchError(editSemanticModel(config, appId, (model) => upsertModelField(model, fieldId, {
       kind: options.kind,
       display: options.displayName,
       expression,
@@ -6568,7 +7725,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, outcome] = await catchError2(editSemanticModel(config, appId, (model) => removeModelField(model, fieldId)));
+    const [err, outcome] = await catchError(editSemanticModel(config, appId, (model) => removeModelField(model, fieldId)));
     if (err) {
       fail(err.message, modelWriteHint(err, `uip pm apps model fields remove ${appId} ${fieldId}`));
       return;
@@ -6591,13 +7748,13 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, file] = await catchError2(pmGetRaw(config, `/apps/${appId}/${options.stage}/inputDataMapping`));
+    const [err, file] = await catchError(pmGetRaw(config, `/apps/${appId}/${options.stage}/inputDataMapping`));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list).");
       return;
     }
     if (options.destination !== undefined) {
-      const [writeErr] = await catchError2(getFileSystem().writeFile(options.destination, file.content));
+      const [writeErr] = await catchError(getFileSystem().writeFile(options.destination, file.content));
       if (writeErr) {
         fail(writeErr.message, "Check the destination path and that the disk is writable.");
         return;
@@ -6617,7 +7774,7 @@ function registerAppsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, tables] = await catchError2(updateDataMapping(config, appId, options));
+    const [err, tables] = await catchError(updateDataMapping(config, appId, options));
     if (err) {
       fail(err.message, isConflictError(err) ? conflictInstructions(`uip pm apps data-mapping get ${appId} --destination <file>`) : "Check the app id, the --file JSON shape, and that " + `--etag is the ETag 'uip pm apps data-mapping get ${appId}' returns.`);
       return;
@@ -6651,8 +7808,8 @@ async function createApp(config, name, options) {
   }
   let dataMapping;
   if (options.dataMapping !== undefined) {
-    const fs = getFileSystem();
-    const raw = await fs.readFile(options.dataMapping, "utf-8");
+    const fs2 = getFileSystem();
+    const raw = await fs2.readFile(options.dataMapping, "utf-8");
     if (raw === null) {
       throw new Error(`Data mapping file not found: ${options.dataMapping}`);
     }
@@ -6721,8 +7878,8 @@ async function addModelTables(config, appId, options) {
     throw new Error(`Table file not found: ${options.file}`);
   }
   const extra = JSON.parse(String(raw));
-  const path = `/apps/${appId}/${options.stage}/dataModel`;
-  const current = await pmGetRaw(config, path);
+  const path2 = `/apps/${appId}/${options.stage}/dataModel`;
+  const current = await pmGetRaw(config, path2);
   if (!current.etag) {
     throw new Error(`The data model of app ${appId} was returned without an ETag, so the update cannot be guarded against concurrent edits.`);
   }
@@ -6731,18 +7888,18 @@ async function addModelTables(config, appId, options) {
   if (added.length === 0) {
     throw new Error(`No tables found in ${options.file}: expected a data-model table { name, primaryKey, foreignKeys }, an array of them, or a { tables } object.`);
   }
-  await pmPutJson(config, path, dataModel, current.etag);
+  await pmPutJson(config, path2, dataModel, current.etag);
   await pmPost(config, `/apps/${appId}/${options.stage}/applyCurrentDatamodel`, {});
   return added;
 }
-async function getModelAndMaybeWrite(config, path, appId, code, destination) {
-  const [err, file] = await catchError2(pmGetRaw(config, path));
+async function getModelAndMaybeWrite(config, path2, appId, code, destination) {
+  const [err, file] = await catchError(pmGetRaw(config, path2));
   if (err) {
     fail(err.message, "Check the app id (uip pm apps list).");
     return;
   }
   if (destination !== undefined) {
-    const [writeErr] = await catchError2(getFileSystem().writeFile(destination, file.content));
+    const [writeErr] = await catchError(getFileSystem().writeFile(destination, file.content));
     if (writeErr) {
       fail(writeErr.message, "Check the destination path and that the disk is writable.");
       return;
@@ -6779,7 +7936,7 @@ async function readExpressionArg(value) {
     }
     text = String(raw);
   }
-  const [parseErr, parsed] = catchError2(() => JSON.parse(text));
+  const [parseErr, parsed] = catchError(() => JSON.parse(text));
   if (parseErr) {
     throw new Error(`Expression is not valid JSON: ${parseErr.message}`);
   }
@@ -6868,14 +8025,14 @@ function removeModelField(model, fieldId) {
   throw new Error(`Field '${fieldId}' not found (see 'uip pm apps model fields list').`);
 }
 async function editSemanticModel(config, appId, mutate) {
-  const path = `/apps/${appId}/dev/model`;
-  const current = await pmGetRaw(config, path);
+  const path2 = `/apps/${appId}/dev/model`;
+  const current = await pmGetRaw(config, path2);
   if (!current.etag) {
     throw new Error(`The model of app ${appId} was returned without an ETag, so the edit cannot be guarded against concurrent changes.`);
   }
   const model = JSON.parse(current.content);
   const result = mutate(model);
-  const put = await pmPutJson(config, path, model, current.etag);
+  const put = await pmPutJson(config, path2, model, current.etag);
   return { result, versions: put?.versions ?? [] };
 }
 async function updateSemanticModel(config, appId, options) {
@@ -6883,7 +8040,7 @@ async function updateSemanticModel(config, appId, options) {
   if (raw === null) {
     throw new Error(`Model file not found: ${options.file}`);
   }
-  const [parseErr, model] = catchError2(() => JSON.parse(String(raw)));
+  const [parseErr, model] = catchError(() => JSON.parse(String(raw)));
   if (parseErr) {
     throw new Error(`Model file is not valid JSON: ${parseErr.message} (${options.file})`);
   }
@@ -6895,7 +8052,7 @@ async function updateDataMapping(config, appId, options) {
   if (raw === null) {
     throw new Error(`Mapping file not found: ${options.file}`);
   }
-  const [parseErr, parsed] = catchError2(() => JSON.parse(String(raw)));
+  const [parseErr, parsed] = catchError(() => JSON.parse(String(raw)));
   if (parseErr) {
     throw new Error(`Mapping file is not valid JSON: ${parseErr.message} (${options.file})`);
   }
@@ -6956,10 +8113,552 @@ function applyMappingDefaults(mapping) {
   return mapping;
 }
 
+// src/commands/conformance.ts
+var STAGES3 = ["dev", "published"];
+var CONFORMANCE_STATUS = [
+  "ModelOnly",
+  "LogOnly",
+  "Conforming",
+  "Accepted"
+];
+var MODEL_BASED_MINERS = new Set([
+  "inductive",
+  "bpmn",
+  "hybrid-bpmn-inductive"
+]);
+var RATE_EXAMPLES = [
+  {
+    Description: "What share of cases follow the reference model",
+    Command: "uip pm conformance rate 9c46289e",
+    Output: {
+      Code: "PmConformanceRate",
+      Data: {
+        ProcessId: "Process",
+        Miner: "inductive",
+        ConformanceRate: 0.666667,
+        ConformingCases: 2,
+        TotalCases: 3
+      }
+    }
+  }
+];
+var ACTIVITIES_EXAMPLES = [
+  {
+    Description: "Per-activity conformance: which steps conform, which only the log has, which only the model expected",
+    Command: "uip pm conformance activities 9c46289e",
+    Output: {
+      Code: "PmConformanceActivities",
+      Data: [
+        { Activity: "Approve", Status: "Conforming", Cases: 2 },
+        { Activity: "Escalate", Status: "LogOnly", Cases: 1 }
+      ]
+    }
+  }
+];
+var TRANSITIONS_EXAMPLES = [
+  {
+    Description: "Per-transition conformance between activities",
+    Command: "uip pm conformance transitions 9c46289e",
+    Output: {
+      Code: "PmConformanceTransitions",
+      Data: [
+        {
+          From: "Start",
+          To: "Approve",
+          Status: "Conforming",
+          Cases: 2
+        }
+      ]
+    }
+  }
+];
+var UPLOAD_MODEL_EXAMPLES = [
+  {
+    Description: "Set the reference model from a BPMN file, then re-ingest so conformance is measured against it",
+    Command: "uip pm conformance upload-model 9c46289e ./order-to-cash.bpmn",
+    Output: {
+      Code: "PmConformanceUploadModel",
+      Data: {
+        AppId: "9c46289e",
+        File: "./order-to-cash.bpmn",
+        Status: "Uploaded",
+        Messages: []
+      }
+    }
+  }
+];
+var DEVIATIONS_EXAMPLES = [
+  {
+    Description: "Deviations the data actually shows, with how many cases each costs",
+    Command: "uip pm conformance deviations 9c46289e",
+    Output: {
+      Code: "PmConformanceDeviations",
+      Data: [
+        {
+          Deviation: "Activity Approve is skipped",
+          Type: "Skip",
+          Cases: 1,
+          AverageThroughputTime: 2700
+        }
+      ]
+    }
+  }
+];
+function registerConformanceCommand(program2) {
+  const cmd = program2.command("conformance").description("A process app's conformance: the reference model it is measured against, the rate, per-activity and per-transition status, and the deviations");
+  register(cmd, {
+    name: "rate",
+    summary: "Share of cases that follow the reference model",
+    code: "PmConformanceRate",
+    examples: RATE_EXAMPLES,
+    run: conformanceRate
+  });
+  register(cmd, {
+    name: "activities",
+    summary: "Conformance status of each activity, with the cases behind it",
+    code: "PmConformanceActivities",
+    examples: ACTIVITIES_EXAMPLES,
+    run: conformanceActivities
+  });
+  register(cmd, {
+    name: "transitions",
+    summary: "Conformance status of each transition between activities, with the cases behind it",
+    code: "PmConformanceTransitions",
+    examples: TRANSITIONS_EXAMPLES,
+    run: conformanceTransitions
+  });
+  register(cmd, {
+    name: "deviations",
+    summary: "Deviations present in the data, with the cases and average throughput time each accounts for",
+    code: "PmConformanceDeviations",
+    examples: DEVIATIONS_EXAMPLES,
+    run: conformanceDeviations
+  });
+  registerUploadModel(cmd);
+}
+var MAX_BPMN_BYTES = 6 * 1024 * 1024;
+function registerUploadModel(group) {
+  group.command("upload-model <app-id> <bpmn-file>").description("Upload a BPMN file as the app's reference model (dev stage; takes effect on the next ingestion)").option("--process-id <id>", "Process the model belongs to; only needed for a multi-process app").examples(UPLOAD_MODEL_EXAMPLES).trackedAction(processContext, async (appId, bpmnFile, options) => {
+    const content = await getFileSystem().readFile(bpmnFile, "utf-8");
+    if (content === null) {
+      fail(`BPMN file not found: ${bpmnFile}`, "Pass the path to a .bpmn file exported from your modelling tool.");
+      return;
+    }
+    const bpmn = String(content);
+    if (Buffer.byteLength(bpmn, "utf-8") > MAX_BPMN_BYTES) {
+      fail(`BPMN file is larger than the 6 MB the API accepts: ${bpmnFile}`, "Trim the model, or split the process so each app carries one.");
+      return;
+    }
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const query = options.processId ? `?processId=${encodeURIComponent(options.processId)}` : "";
+    const [err, result] = await catchError(pmPutBinaryJson(config, `/apps/${appId}/dev/bpmn${query}`, bpmn));
+    if (err) {
+      fail(err.message, "Check the app id (uip pm apps list), that the file is valid BPMN, and that you have edit permission. Uploads only work on the dev stage.");
+      return;
+    }
+    const payload = result ?? {};
+    const messages = field(payload, "messages") ?? [];
+    if (field(payload, "hasError") === true) {
+      fail(`The BPMN model was rejected: ${JSON.stringify(messages)}`, "Fix the reported problems in the model and upload it again.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmConformanceUploadModel",
+      Data: {
+        AppId: appId,
+        File: bpmnFile,
+        Status: "Uploaded",
+        Messages: messages
+      }
+    });
+  });
+}
+function register(group, spec) {
+  group.command(`${spec.name} <app-id>`).description(spec.summary).option("--process-id <id>", "Process to report on; only needed for a multi-process app").addOption(new Option("--stage <stage>", "App stage").choices(STAGES3).default("dev")).examples(spec.examples).trackedAction(processContext, async (appId, options) => {
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const [infoErr, process2] = await catchError(resolveProcess(config, appId, options));
+    if (infoErr || !process2) {
+      fail(infoErr?.message ?? "Could not resolve the process.", "Check the app id (uip pm apps list) and that the stage has a completed ingestion. 'uip pm query info' lists the processes.");
+      return;
+    }
+    const [err, data] = await catchError(spec.run(config, appId, options.stage, process2));
+    if (err) {
+      fail(err.message, "Check the app id (uip pm apps list) and that the stage has a completed ingestion.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: spec.code,
+      Data: data
+    });
+  });
+}
+function sub(obj, name) {
+  return field(obj ?? {}, name) ?? {};
+}
+var str = (obj, name) => {
+  const value = field(obj, name);
+  return typeof value === "string" && value.length > 0 ? value : null;
+};
+async function resolveProcess(config, appId, options) {
+  const info = await pmGet(config, `/query/${appId}/${options.stage}/info`);
+  const internal = sub(info, "internalFields");
+  const processes = field(internal, "processes") ?? [];
+  if (processes.length === 0) {
+    throw new Error(`App '${appId}' exposes no processes, so it has no conformance data.`);
+  }
+  const wanted = options.processId;
+  const match = wanted ? processes.find((p) => str(p, "processId") === wanted) : processes[0];
+  if (!match) {
+    const known = processes.map((p) => str(p, "processId") ?? "?").join(", ");
+    throw new Error(`Process '${wanted}' not found on app '${appId}'. Available: ${known}.`);
+  }
+  const cases = sub(match, "cases");
+  const events = sub(match, "events");
+  const transitions = sub(match, "transitions");
+  const deviations = sub(match, "variationDeviations");
+  const processId = str(match, "processId") ?? "";
+  const miner = str(match, "miner") ?? "";
+  const caseConforming = str(cases, "caseConforming");
+  if (caseConforming === null || !MODEL_BASED_MINERS.has(miner)) {
+    throw new Error(`Process '${processId}' uses the '${miner || "unknown"}' miner and has no reference model, so it has no conformance data. ` + "Conformance needs a model-based app — create one with 'uip pm apps create --miner inductive' (or bpmn).");
+  }
+  return {
+    processId,
+    miner,
+    caseId: str(cases, "caseId") ?? "",
+    caseConforming,
+    caseThroughputTime: str(cases, "caseThroughputTime"),
+    activity: str(events, "activity") ?? "",
+    nodeId: str(events, "nodeId") ?? "",
+    eventConformance: str(events, "eventConformance"),
+    fromNodeId: str(transitions, "fromNodeId") ?? "",
+    toNodeId: str(transitions, "toNodeId") ?? "",
+    transitionConformance: str(transitions, "transitionConformance"),
+    deviation: str(deviations, "deviation"),
+    deviationType: str(deviations, "deviationType")
+  };
+}
+async function runQuery(config, appId, stage, body) {
+  const result = await pmPost(config, `/query/${appId}/${stage}`, body);
+  return result ?? {};
+}
+function cell(response, id) {
+  const target = sanitizeKey(id);
+  for (const [key, value] of Object.entries(response)) {
+    if (sanitizeKey(key) === target) {
+      return value ?? {};
+    }
+  }
+  return {};
+}
+var values = (c) => field(c, "values") ?? [];
+var ungrouped = (c) => field(c, "ungrouped") ?? null;
+function statusName(value) {
+  if (typeof value === "number")
+    return CONFORMANCE_STATUS[value] ?? value;
+  return value ?? null;
+}
+var asNumber = (value) => typeof value === "number" ? value : null;
+async function conformanceRate(config, appId, stage, process2) {
+  const aggregates = [
+    {
+      id: "rate",
+      argument: process2.caseConforming,
+      aggregation: "PERCENTAGE"
+    },
+    {
+      id: "total_cases",
+      argument: process2.caseId,
+      aggregation: "DISTINCT_COUNT"
+    }
+  ];
+  const response = await runQuery(config, appId, stage, {
+    groupBy: [],
+    aggregates
+  });
+  const rateCell = cell(response, "rate");
+  const totalCell = cell(response, "total_cases");
+  const rate = asNumber(ungrouped(rateCell) ?? values(rateCell)[0]);
+  const total = asNumber(ungrouped(totalCell) ?? values(totalCell)[0]);
+  return {
+    ProcessId: process2.processId,
+    Miner: process2.miner,
+    ConformanceRate: rate,
+    ConformingCases: rate !== null && total !== null ? Math.round(rate * total) : null,
+    TotalCases: total
+  };
+}
+async function conformanceActivities(config, appId, stage, process2) {
+  if (!process2.eventConformance) {
+    throw new Error(`Process '${process2.processId}' has no event conformance field, so per-activity status is unavailable.`);
+  }
+  const aggregates = [
+    {
+      id: "cases",
+      argument: process2.caseId,
+      aggregation: "DISTINCT_COUNT"
+    },
+    {
+      id: "status",
+      argument: process2.eventConformance,
+      aggregation: "MAX"
+    }
+  ];
+  const response = await runQuery(config, appId, stage, {
+    groupBy: [process2.activity],
+    aggregates,
+    isProcessGraph: true
+  });
+  const activities = values(cell(response, process2.activity));
+  const cases = values(cell(response, "cases"));
+  const status = values(cell(response, "status"));
+  return activities.map((name, i) => ({
+    Activity: name ?? null,
+    Status: statusName(status[i]),
+    Cases: asNumber(cases[i])
+  }));
+}
+async function conformanceTransitions(config, appId, stage, process2) {
+  if (!process2.transitionConformance) {
+    throw new Error(`Process '${process2.processId}' has no transition conformance field, so per-transition status is unavailable.`);
+  }
+  const aggregates = [
+    {
+      id: "cases",
+      argument: process2.caseId,
+      aggregation: "DISTINCT_COUNT"
+    },
+    {
+      id: "status",
+      argument: process2.transitionConformance,
+      aggregation: "MAX"
+    }
+  ];
+  const response = await runQuery(config, appId, stage, {
+    groupBy: [process2.fromNodeId, process2.toNodeId],
+    aggregates,
+    isProcessGraph: true
+  });
+  const from = values(cell(response, process2.fromNodeId));
+  const to = values(cell(response, process2.toNodeId));
+  const cases = values(cell(response, "cases"));
+  const status = values(cell(response, "status"));
+  return from.map((fromNode, i) => ({
+    FromNodeId: fromNode ?? null,
+    ToNodeId: to[i] ?? null,
+    Status: statusName(status[i]),
+    Cases: asNumber(cases[i])
+  }));
+}
+async function conformanceDeviations(config, appId, stage, process2) {
+  if (!process2.deviation || !process2.deviationType) {
+    throw new Error(`Process '${process2.processId}' exposes no deviation fields, so there are no deviations to report.`);
+  }
+  const aggregates = [
+    {
+      id: "cases",
+      argument: process2.caseId,
+      aggregation: "DISTINCT_COUNT"
+    }
+  ];
+  if (process2.caseThroughputTime) {
+    aggregates.push({
+      id: "throughput",
+      argument: process2.caseThroughputTime,
+      aggregation: "AVERAGE"
+    });
+  }
+  const response = await runQuery(config, appId, stage, {
+    groupBy: [process2.deviation, process2.deviationType],
+    aggregates
+  });
+  const deviations = values(cell(response, process2.deviation));
+  const types = values(cell(response, process2.deviationType));
+  const cases = values(cell(response, "cases"));
+  const throughput = values(cell(response, "throughput"));
+  return deviations.map((deviation, i) => ({
+    Deviation: deviation ?? null,
+    Type: types[i] ?? null,
+    Cases: asNumber(cases[i]),
+    AverageThroughputTime: asNumber(throughput[i])
+  })).filter((row) => row.Deviation !== null);
+}
+
+// src/commands/deviations.ts
+var STAGES4 = ["dev", "published"];
+var DEFAULT_PROCESS_ID = "Process";
+var STATUSES = ["Applied", "AppliedButDeleted", "NotApplied"];
+var DEVIATIONS_LIST_EXAMPLES = [
+  {
+    Description: "List the deviations accepted on an app, with whether the last ingestion has them",
+    Command: "uip pm deviations list 9c46289e",
+    Output: {
+      Code: "PmDeviationsList",
+      Data: [
+        {
+          Type: "activity_missing",
+          Activities: ["Approve order"],
+          ParentProcess: [],
+          Status: "NotApplied"
+        }
+      ]
+    }
+  }
+];
+var DEVIATIONS_ACCEPT_EXAMPLES = [
+  {
+    Description: "Accept a deviation, then re-run transformations to apply it (until then it lists as NotApplied)",
+    Command: 'uip pm deviations accept 9c46289e --type activity_missing --activities "Approve order"',
+    Output: {
+      Code: "PmDeviationsAccept",
+      Data: {
+        AppId: "9c46289e",
+        Type: "activity_missing",
+        Activities: ["Approve order"],
+        Status: "Accepted"
+      }
+    }
+  }
+];
+var DEVIATIONS_DELETE_EXAMPLES = [
+  {
+    Description: "Stop accepting a deviation",
+    Command: 'uip pm deviations delete 9c46289e --type activity_missing --activities "Approve order"',
+    Output: {
+      Code: "PmDeviationsDelete",
+      Data: {
+        AppId: "9c46289e",
+        Type: "activity_missing",
+        Activities: ["Approve order"],
+        Status: "Deleted"
+      }
+    }
+  }
+];
+function registerDeviationsCommand(program2) {
+  const devCmd = program2.command("deviations").description("Manage the deviations accepted on a process app: list, accept, delete");
+  devCmd.command("list <app-id>").description("List the accepted deviations and whether the last ingestion has them applied").addOption(processIdOption()).addOption(new Option("--stage <stage>", "App stage").choices(STAGES4).default("dev")).examples(DEVIATIONS_LIST_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const [err, result] = await catchError(pmGet(config, deviationsPath(appId, options)));
+    if (err) {
+      fail(err.message, LIST_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmDeviationsList",
+      Data: normalizeDeviations(unwrapData(result))
+    });
+  });
+  devCmd.command("accept <app-id>").description("Accept a deviation so conformance stops counting it against the app").requiredOption("--type <deviation-type>", "Deviation type, as reported in the app's deviation data").requiredOption("--activities <activities...>", "Activity names the deviation covers (space-separated; quote names containing spaces)").addOption(processIdOption()).examples(DEVIATIONS_ACCEPT_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const body = buildDeviationBody(options);
+    const [err] = await catchError(pmPost(config, deviationsPath(appId, options), body));
+    if (err) {
+      fail(err.message, WRITE_INSTRUCTIONS + " A deviation that is already accepted is rejected as a duplicate — see 'uip pm deviations list'.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmDeviationsAccept",
+      Data: {
+        AppId: appId,
+        Type: body.type,
+        Activities: body.activities,
+        Status: "Accepted"
+      }
+    });
+  });
+  devCmd.command("delete <app-id>").description("Stop accepting a deviation").requiredOption("--type <deviation-type>", "Deviation type, as reported in the app's deviation data").requiredOption("--activities <activities...>", "Activity names the deviation covers (space-separated; quote names containing spaces)").addOption(processIdOption()).examples(DEVIATIONS_DELETE_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const body = buildDeviationBody(options);
+    const [err] = await catchError(pmDelete(config, deviationsPath(appId, options), body));
+    if (err) {
+      fail(err.message, WRITE_INSTRUCTIONS + " The type, activities and parent process must match an accepted deviation exactly — list them with 'uip pm deviations list'.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmDeviationsDelete",
+      Data: {
+        AppId: appId,
+        Type: body.type,
+        Activities: body.activities,
+        Status: "Deleted"
+      }
+    });
+  });
+  devCmd.command("delete-all <app-id>").description("Stop accepting every deviation on the app").option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").addOption(processIdOption()).trackedAction(processContext, async (appId, options) => {
+    if (!requireConfirmation(options, `delete every accepted deviation on process app '${appId}'`))
+      return;
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const [err] = await catchError(pmDelete(config, `${deviationsPath(appId, options)}/all`));
+    if (err) {
+      fail(err.message, WRITE_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmDeviationsDeleteAll",
+      Data: { AppId: appId, Status: "Deleted" }
+    });
+  });
+}
+function processIdOption() {
+  return new Option("--process-id <id>", "Process id (from 'uip pm query info'); only matters for a multi-process app").default(DEFAULT_PROCESS_ID);
+}
+function deviationsPath(appId, options) {
+  const stage = options.stage ?? "dev";
+  return `/apps/${appId}/${stage}/${options.processId}/accepted-deviations`;
+}
+function buildDeviationBody(options) {
+  return {
+    type: options.type,
+    activities: (options.activities ?? []).filter((value) => value.length > 0),
+    parentProcess: []
+  };
+}
+function normalizeDeviations(payload) {
+  if (!Array.isArray(payload))
+    return payload;
+  return payload.map((row) => {
+    if (row === null || typeof row !== "object")
+      return row;
+    const r = row;
+    return {
+      Type: field(r, "type") ?? null,
+      Activities: field(r, "activity") ?? field(r, "activities") ?? [],
+      ParentProcess: field(r, "parentProcess") ?? [],
+      Status: readStatus(field(r, "status"))
+    };
+  });
+}
+function readStatus(status) {
+  if (typeof status === "number")
+    return STATUSES[status] ?? status;
+  return status ?? null;
+}
+var LIST_INSTRUCTIONS = "Check the app id (uip pm apps list), that the stage has a completed ingestion, " + "and the --process-id (uip pm query info lists the processes).";
+var WRITE_INSTRUCTIONS = "Writes only work on the dev stage and need edit permission on the app. " + "Check the app id (uip pm apps list) and the --process-id (uip pm query info).";
+
 // src/commands/files.ts
 var CHUNK_SIZE = 5 * 1024 * 1024;
 var MAX_CONCURRENT_UPLOADS = 4;
-var STAGES3 = ["dev", "published"];
+var STAGES5 = ["dev", "published"];
 var FILES_UPLOAD_EXAMPLES = [
   {
     Description: "Upload an event-log CSV from a sample dataset",
@@ -6972,11 +8671,11 @@ var FILES_UPLOAD_EXAMPLES = [
 ];
 function registerFilesCommand(program2) {
   const filesCmd = program2.command("files").description("Upload data files to a process app");
-  filesCmd.command("upload <app-id> <file-path>").description("Upload a data file to a process app via chunked blob upload").addOption(new Option("--stage <stage>", "App stage to upload to").choices(STAGES3).default("dev")).option("--input-table <name>", "Target input table the file belongs to (e.g. 'Event_log')").examples(FILES_UPLOAD_EXAMPLES).trackedAction(processContext, async (appId, filePath, options) => {
+  filesCmd.command("upload <app-id> <file-path>").description("Upload a data file to a process app via chunked blob upload").addOption(new Option("--stage <stage>", "App stage to upload to").choices(STAGES5).default("dev")).option("--input-table <name>", "Target input table the file belongs to (e.g. 'Event_log')").examples(FILES_UPLOAD_EXAMPLES).trackedAction(processContext, async (appId, filePath, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, result] = await catchError2(uploadFile(config, appId, filePath, options));
+    const [err, result] = await catchError(uploadFile(config, appId, filePath, options));
     if (err) {
       fail(err.message, "Check the app id, file path, and that no ingestion is currently in progress.");
       return;
@@ -6989,13 +8688,13 @@ function registerFilesCommand(program2) {
   });
 }
 async function uploadFile(config, appId, filePath, options) {
-  const fs = getFileSystem();
-  const bytes = await fs.readFile(filePath);
+  const fs2 = getFileSystem();
+  const bytes = await fs2.readFile(filePath);
   if (bytes === null) {
     throw new Error(`File not found: ${filePath}`);
   }
   const size = bytes.length;
-  const filename = fs.path.basename(filePath);
+  const filename = fs2.path.basename(filePath);
   const startResponse = await pmPost(config, `/upload/${appId}/${options.stage}`, { filename, size, inputTable: options.inputTable });
   if (startResponse === null) {
     throw new Error("Start-upload returned an empty response.");
@@ -7062,7 +8761,7 @@ async function uploadPart(config, part, content) {
 }
 
 // src/commands/ingestions.ts
-var STAGES4 = ["dev", "published"];
+var STAGES6 = ["dev", "published"];
 var FILE_FORMATS = ["csv", "tsv"];
 var ENCODINGS = ["utf-8", "iso-8859-1"];
 var INGESTIONS_CREATE_EXAMPLES = [
@@ -7101,20 +8800,20 @@ var INGESTIONS_LOGS_EXAMPLES = [
 ];
 function registerIngestionsCommand(program2) {
   const ingestionsCmd = program2.command("ingestions").description("Trigger and inspect data ingestions of a process app");
-  ingestionsCmd.command("create <app-id>").description("Trigger an ingestion of the uploaded data files").addOption(new Option("--stage <stage>", "App stage to ingest into").choices(STAGES4).default("dev")).addOption(new Option("--file-format <format>", "Data file format").choices(FILE_FORMATS).default("csv")).option("--field-delimiter <char>", "Field delimiter in the data files", ",").option("--quote-character <char>", "Quote character enclosing fields", '"').addOption(new Option("--encoding <encoding>", "File encoding").choices(ENCODINGS).default("utf-8")).option("--wait", "Block until the ingestion reaches a terminal state; exit non-zero on failure").option("--timeout <seconds>", "Max seconds to wait when --wait is set", "1800").option("--poll-interval <seconds>", "Seconds between status polls when --wait is set", "5").examples(INGESTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+  ingestionsCmd.command("create <app-id>").description("Trigger an ingestion of the uploaded data files").addOption(new Option("--stage <stage>", "App stage to ingest into").choices(STAGES6).default("dev")).addOption(new Option("--file-format <format>", "Data file format").choices(FILE_FORMATS).default("csv")).option("--field-delimiter <char>", "Field delimiter in the data files", ",").option("--quote-character <char>", "Quote character enclosing fields", '"').addOption(new Option("--encoding <encoding>", "File encoding").choices(ENCODINGS).default("utf-8")).option("--wait", "Block until the ingestion reaches a terminal state; exit non-zero on failure").option("--timeout <seconds>", "Max seconds to wait when --wait is set", "1800").option("--poll-interval <seconds>", "Seconds between status polls when --wait is set", "5").examples(INGESTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
     let before = {};
     if (options.wait) {
-      const [readErr, snapshot] = await catchError2(readLastIngestion(config, appId, options.stage));
+      const [readErr, snapshot] = await catchError(readLastIngestion(config, appId, options.stage));
       if (readErr) {
         fail(readErr.message, "Check the app id (uip pm apps list) and your authentication.");
         return;
       }
       before = snapshot;
     }
-    const [err, result] = await catchError2(pmPost(config, `/apps/${appId}/${options.stage}/ingest`, {
+    const [err, result] = await catchError(pmPost(config, `/apps/${appId}/${options.stage}/ingest`, {
       fileFormat: options.fileFormat,
       fileFormatOptions: {
         fieldDelimiter: options.fieldDelimiter,
@@ -7139,11 +8838,11 @@ function registerIngestionsCommand(program2) {
       }
     });
   });
-  ingestionsCmd.command("cancel <app-id> <ingestion-id>").description("Cancel an ingestion that is still running").addOption(new Option("--stage <stage>", "App stage the ingestion runs on").choices(STAGES4).default("dev")).examples(INGESTIONS_CANCEL_EXAMPLES).trackedAction(processContext, async (appId, ingestionId, options) => {
+  ingestionsCmd.command("cancel <app-id> <ingestion-id>").description("Cancel an ingestion that is still running").addOption(new Option("--stage <stage>", "App stage the ingestion runs on").choices(STAGES6).default("dev")).examples(INGESTIONS_CANCEL_EXAMPLES).trackedAction(processContext, async (appId, ingestionId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err] = await catchError2(pmPost(config, `/apps/${appId}/${options.stage}/ingestions/${ingestionId}/cancel`));
+    const [err] = await catchError(pmPost(config, `/apps/${appId}/${options.stage}/ingestions/${ingestionId}/cancel`));
     if (err) {
       fail(err.message, `Check the ingestion id ('uip pm apps get ${appId}' shows LastIngestion) and that it is still running.`);
       return;
@@ -7158,7 +8857,7 @@ function registerIngestionsCommand(program2) {
       }
     });
   });
-  ingestionsCmd.command("logs <app-id> <ingestion-id>").description("Get the logs of an ingestion run").addOption(new Option("--stage <stage>", "App stage the ingestion ran on").choices(STAGES4).default("dev")).option("--limit <number>", "Max log entries to fetch (page size)", "100").option("--offset <number>", "Number of log entries to skip before the page", "0").examples(INGESTIONS_LOGS_EXAMPLES).trackedAction(processContext, async (appId, ingestionId, options) => {
+  ingestionsCmd.command("logs <app-id> <ingestion-id>").description("Get the logs of an ingestion run").addOption(new Option("--stage <stage>", "App stage the ingestion ran on").choices(STAGES6).default("dev")).option("--limit <number>", "Max log entries to fetch (page size)", "100").option("--offset <number>", "Number of log entries to skip before the page", "0").examples(INGESTIONS_LOGS_EXAMPLES).trackedAction(processContext, async (appId, ingestionId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
@@ -7166,7 +8865,7 @@ function registerIngestionsCommand(program2) {
     const offset = Number.parseInt(options.offset, 10);
     const pageSize = limit > 0 ? limit : 100;
     const pageNumber = offset > 0 ? Math.floor(offset / pageSize) + 1 : 1;
-    const [err, result] = await catchError2(pmGet(config, `/apps/${appId}/${options.stage}/logs/${ingestionId}?pageNumber=${pageNumber}&pageSize=${pageSize}`));
+    const [err, result] = await catchError(pmGet(config, `/apps/${appId}/${options.stage}/logs/${ingestionId}?pageNumber=${pageNumber}&pageSize=${pageSize}`));
     if (err) {
       fail(err.message, "Check the app id and ingestion id (uip pm apps list shows LastIngestion).");
       return;
@@ -7180,7 +8879,7 @@ function registerIngestionsCommand(program2) {
 }
 
 // src/commands/query.ts
-var STAGES5 = ["dev", "published"];
+var STAGES7 = ["dev", "published"];
 var LAYOUT_TYPES = ["graph", "process-model"];
 var QUERY_RUN_EXAMPLES = [
   {
@@ -7192,14 +8891,36 @@ var QUERY_RUN_EXAMPLES = [
     }
   },
   {
-    Description: "Raw aggregate body. groupBy/argument take field ids from 'query info'; aggregation is average|count|sum|min|max",
-    Command: `uip pm query run 9c46289e --body-json '{"groupBy":["F__Cases__Priority__..."],"aggregates":[{"id":"n","argument":"Case_ID","aggregation":"count"}]}'`,
+    Description: "Raw aggregate body. groupBy/argument take field ids from 'query info'; see --metric for the aggregations",
+    Command: `uip pm query run 9c46289e --body-json '{"groupBy":["F__Cases__Priority__..."],"aggregates":[{"id":"n","argument":"Case_ID","aggregation":"COUNT"}]}'`,
     Output: {
       Code: "PmQueryRun",
       Data: {
         n: { Ungrouped: 1043 }
       }
     }
+  },
+  {
+    Description: "Conformance rate: the share of cases that follow the reference model (the process' conforming field comes from 'query info')",
+    Command: "uip pm query run 9c46289e --metric Case_conforming:percentage",
+    Output: {
+      Code: "PmQueryRun",
+      Data: [{ percentage_Case_conforming: 82.4 }]
+    }
+  },
+  {
+    Description: "Skipped steps: activities the model expected that a case did not take, counted by case. Drop --conformance for the same query over what the log did do",
+    Command: "uip pm query run 9c46289e --group-by Node_id,Node_label --metric Case_ID:distinct_count --process-graph --conformance",
+    Output: {
+      Code: "PmQueryRun",
+      Data: [
+        {
+          Node_id: 3,
+          Node_label: "Approve order",
+          distinct_count_Case_ID: 87
+        }
+      ]
+    }
   }
 ];
 var QUERY_RCA_EXAMPLES = [
@@ -7232,7 +8953,19 @@ var QUERY_PERCENTILE_EXAMPLES = [
     }
   }
 ];
-var AGGREGATIONS = new Set(["average", "count", "sum", "min", "max"]);
+var AGGREGATIONS = new Map([
+  ["any", "ANY"],
+  ["average", "AVERAGE"],
+  ["count", "COUNT"],
+  ["distinct_count", "DISTINCT_COUNT"],
+  ["forall", "FORALL"],
+  ["forany", "FORANY"],
+  ["max", "MAX"],
+  ["median", "MEDIAN"],
+  ["min", "MIN"],
+  ["percentage", "PERCENTAGE"],
+  ["sum", "SUM"]
+]);
 function registerQueryCommand(program2) {
   const queryCmd = program2.command("query").description("Query a process app: aggregate data, details, RCA, insights, " + "percentiles, layout and query metadata");
   registerBodyQuery(queryCmd, {
@@ -7266,11 +8999,11 @@ function registerQueryCommand(program2) {
     summary: "Run process insights (body needs 'processId' and 1..10 'metrics')",
     withLimit: true
   });
-  queryCmd.command("info <app-id>").description("Get query metadata: the fields, metrics and processes available to build query bodies").addOption(new Option("--stage <stage>", "App stage").choices(STAGES5).default("dev")).examples(QUERY_INFO_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+  queryCmd.command("info <app-id>").description("Get query metadata: the fields, metrics and processes available to build query bodies").addOption(new Option("--stage <stage>", "App stage").choices(STAGES7).default("dev")).examples(QUERY_INFO_EXAMPLES).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, result] = await catchError2(pmGet(config, `/query/${appId}/${options.stage}/info`));
+    const [err, result] = await catchError(pmGet(config, `/query/${appId}/${options.stage}/info`));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list) and that the stage has a completed ingestion.");
       return;
@@ -7281,12 +9014,12 @@ function registerQueryCommand(program2) {
       Data: result
     });
   });
-  queryCmd.command("layout <app-id>").description("Get the persisted global graph layout of a process app").addOption(new Option("--type <type>", "Layout to read: the process 'graph' or the 'process-model'").choices(LAYOUT_TYPES).default("graph")).addOption(new Option("--stage <stage>", "App stage").choices(STAGES5).default("dev")).trackedAction(processContext, async (appId, options) => {
+  queryCmd.command("layout <app-id>").description("Get the persisted global graph layout of a process app").addOption(new Option("--type <type>", "Layout to read: the process 'graph' or the 'process-model'").choices(LAYOUT_TYPES).default("graph")).addOption(new Option("--stage <stage>", "App stage").choices(STAGES7).default("dev")).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
     const endpoint = options.type === "process-model" ? "processModelGlobalLayout" : "graphLayout";
-    const [err, result] = await catchError2(pmGet(config, `/query/${appId}/${options.stage}/${endpoint}`));
+    const [err, result] = await catchError(pmGet(config, `/query/${appId}/${options.stage}/${endpoint}`));
     if (err) {
       fail(err.message, "Check the app id (uip pm apps list) and that the stage has a completed ingestion.");
       return;
@@ -7297,16 +9030,16 @@ function registerQueryCommand(program2) {
       Data: result
     });
   });
-  queryCmd.command("percentile <app-id>").description("Compute percentiles of a numeric field").requiredOption("--field <field-id>", "Field id to compute percentiles over (uip pm query info)").requiredOption("--values <list>", "Comma-separated percentile points in 0..1, e.g. '0.5,0.9,0.95'").option("--filters <json-file>", "Path to a JSON file with a filter spec (array of AND-ed filter groups)").option("--filters-json <json>", "Inline JSON filter spec").addOption(new Option("--stage <stage>", "App stage").choices(STAGES5).default("dev")).examples(QUERY_PERCENTILE_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+  queryCmd.command("percentile <app-id>").description("Compute percentiles of a numeric field").requiredOption("--field <field-id>", "Field id to compute percentiles over (uip pm query info)").requiredOption("--values <list>", "Comma-separated percentile points in 0..1, e.g. '0.5,0.9,0.95'").option("--filters <json-file>", "Path to a JSON file with a filter spec (array of AND-ed filter groups)").option("--filters-json <json>", "Inline JSON filter spec").addOption(new Option("--stage <stage>", "App stage").choices(STAGES7).default("dev")).examples(QUERY_PERCENTILE_EXAMPLES).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [buildErr, body] = await catchError2(buildPercentileBody(options));
+    const [buildErr, body] = await catchError(buildPercentileBody(options));
     if (buildErr) {
       fail(buildErr.message, "Pass --values as comma-separated numbers in 0..1 and a valid --filters/--filters-json spec.");
       return;
     }
-    const [err, result] = await catchError2(pmPost(config, `/query/${appId}/${options.stage}/percentile`, body));
+    const [err, result] = await catchError(pmPost(config, `/query/${appId}/${options.stage}/percentile`, body));
     if (err) {
       fail(err.message, "Check the app id, the field id (uip pm query info) and that the stage has a completed ingestion.");
       return;
@@ -7319,12 +9052,12 @@ function registerQueryCommand(program2) {
   });
 }
 function registerBodyQuery(queryCmd, spec) {
-  const cmd = queryCmd.command(`${spec.name} <app-id>`).description(spec.summary).option("--body <json-file>", "Path to a JSON file with the request body").option("--body-json <json>", "Inline JSON request body").addOption(new Option("--stage <stage>", "App stage").choices(STAGES5).default("dev"));
+  const cmd = queryCmd.command(`${spec.name} <app-id>`).description(spec.summary).option("--body <json-file>", "Path to a JSON file with the request body").option("--body-json <json>", "Inline JSON request body").addOption(new Option("--stage <stage>", "App stage").choices(STAGES7).default("dev"));
   if (spec.withLimit) {
     cmd.option("--limit <n>", "Max rows to return (server clamps to 1..1000)");
   }
   if (spec.withSugar) {
-    cmd.option("--group-by <cols>", "Comma-separated field columns (names or ids) to group by").option("--metric <col:fn[:alias]>", "Aggregate a numeric field; fn is average|count|sum|min|max. Repeatable.", (val, prev) => [...prev, val], []);
+    cmd.option("--group-by <cols>", "Comma-separated field columns (names or ids) to group by").option("--metric <col:fn[:alias]>", `Aggregate a field; fn is ${[...AGGREGATIONS.keys()].join("|")}. Repeatable.`, (val, prev) => [...prev, val], []).option("--process-graph", "Answer over the process graph (activities and transitions) rather than the plain data model").option("--conformance", "Answer over the model-only side: the steps the reference model expected of a case that the case did not take, so a skipped activity shows up against the cases that skipped it. Without it the query answers over what the log did do");
   }
   if (spec.examples) {
     cmd.examples(spec.examples);
@@ -7333,14 +9066,14 @@ function registerBodyQuery(queryCmd, spec) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [prepErr, prepared] = await catchError2(resolveRunBody(config, appId, spec, options));
+    const [prepErr, prepared] = await catchError(resolveRunBody(config, appId, spec, options));
     if (prepErr || !prepared) {
       fail(prepErr?.message ?? "Failed to resolve the query body.", "Pass a body with --body/--body-json, or use --group-by/--metric (names from 'uip pm query info') — the two are mutually exclusive.");
       return;
     }
     const { body, reshape } = prepared;
     const query = options.limit === undefined ? "" : `?limit=${encodeURIComponent(options.limit)}`;
-    const [apiErr, result] = await catchError2(pmPost(config, `/query/${appId}/${options.stage}${spec.subpath}${query}`, body));
+    const [apiErr, result] = await catchError(pmPost(config, `/query/${appId}/${options.stage}${spec.subpath}${query}`, body));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list), that the stage has a completed ingestion, and the request body shape.");
       return;
@@ -7355,6 +9088,9 @@ function registerBodyQuery(queryCmd, spec) {
 async function resolveRunBody(config, appId, spec, options) {
   const usingSugar = spec.withSugar === true && (options.groupBy !== undefined || (options.metric?.length ?? 0) > 0);
   if (!usingSugar) {
+    if (options.processGraph === true || options.conformance === true) {
+      throw new Error("--process-graph/--conformance only apply to the --group-by/--metric sugar. " + "A raw body already carries 'isProcessGraph'/'isConformance'.");
+    }
     return {
       body: await resolveJsonBody(options.body, options.bodyJson),
       reshape: null
@@ -7379,24 +9115,24 @@ async function buildAggregateBody(config, appId, options) {
   if (!config)
     return null;
   const info = await pmGet(config, `/query/${appId}/${options.stage}/info`);
-  const resolve = buildFieldResolver(info);
+  const resolve2 = buildFieldResolver(info);
   const groupCols = (options.groupBy ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  const groupIds = groupCols.map(resolve);
+  const groupIds = groupCols.map(resolve2);
   const metrics = (options.metric ?? []).map(parseMetricSpec);
   const aggregates = metrics.map((m) => ({
     id: m.alias,
-    argument: resolve(m.column),
+    argument: resolve2(m.column),
     aggregation: m.fn
   }));
   if (groupIds.length === 0 && aggregates.length === 0) {
     throw new Error("Provide at least one --group-by column or --metric.");
   }
-  return {
-    body: { groupBy: groupIds, aggregates },
-    groupCols,
-    groupIds,
-    metrics
-  };
+  const body = { groupBy: groupIds, aggregates };
+  if (options.processGraph === true)
+    body.isProcessGraph = true;
+  if (options.conformance === true)
+    body.isConformance = true;
+  return { body, groupCols, groupIds, metrics };
 }
 function parseMetricSpec(spec) {
   const parts = spec.split(":").map((s) => s.trim());
@@ -7404,13 +9140,14 @@ function parseMetricSpec(spec) {
   if (!column || !fn) {
     throw new Error(`Invalid --metric '${spec}': expected 'column:fn' (e.g. 'Event_count:average').`);
   }
-  if (!AGGREGATIONS.has(fn)) {
-    throw new Error(`Invalid aggregation '${fn}' in --metric '${spec}': use ${[...AGGREGATIONS].join(", ")}.`);
+  const name = fn.toLowerCase().replace(/-/g, "_");
+  const wireFn = AGGREGATIONS.get(name);
+  if (wireFn === undefined) {
+    throw new Error(`Invalid aggregation '${fn}' in --metric '${spec}': use ${[...AGGREGATIONS.keys()].join(", ")}.`);
   }
   const safeCol = column.replace(/[^A-Za-z0-9]/g, "_");
-  return { alias: alias || `${fn}_${safeCol}`, column, fn };
+  return { alias: alias || `${name}_${safeCol}`, column, fn: wireFn };
 }
-var sanitizeKey = (s) => s.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
 function buildFieldResolver(info) {
   const byName = new Map;
   const ids = new Set;
@@ -7443,14 +9180,14 @@ function reshapeAggregate(result, groupCols, groupIds, metrics) {
   const keyMap = new Map;
   for (const k of Object.keys(data))
     keyMap.set(sanitizeKey(k), k);
-  const cell = (id) => {
+  const cell2 = (id) => {
     const k = keyMap.get(sanitizeKey(id));
     return k ? data[k] : undefined;
   };
   const valuesOf = (c) => field(c ?? {}, "values") ?? [];
   const ungroupedOf = (c) => field(c ?? {}, "ungrouped") ?? null;
-  const groupCells = groupIds.map((id) => cell(id));
-  const metricCells = metrics.map((m) => cell(m.alias));
+  const groupCells = groupIds.map((id) => cell2(id));
+  const metricCells = metrics.map((m) => cell2(m.alias));
   if (groupCols.length === 0) {
     const totals = {};
     metrics.forEach((m, i) => {
@@ -7475,19 +9212,64 @@ function reshapeAggregate(result, groupCols, groupIds, metrics) {
   return rows;
 }
 async function buildPercentileBody(options) {
-  const values = options.values.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map(Number);
-  if (values.length === 0 || values.some((v) => !Number.isFinite(v))) {
+  const values2 = options.values.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map(Number);
+  if (values2.length === 0 || values2.some((v) => !Number.isFinite(v))) {
     throw new Error(`Invalid --values '${options.values}': expected comma-separated numbers.`);
   }
   let filters = [];
   if (options.filters !== undefined || options.filtersJson !== undefined) {
     filters = await resolveJsonBody(options.filters, options.filtersJson, "filters");
   }
-  return { field: options.field, values, filters };
+  return { field: options.field, values: values2, filters };
+}
+
+// src/commands/simulations.ts
+var STAGES8 = ["dev", "published"];
+var SIMULATIONS_LIST_EXAMPLES = [
+  {
+    Description: "List the simulations saved on a process app's dev stage",
+    Command: "uip pm simulations list 9c46289e",
+    Output: {
+      Code: "PmSimulationsList",
+      Data: [
+        {
+          DefinitionMetadata: {
+            Name: "Two more approvers",
+            SimulationId: "bfd3d274-a5cc-429c-9d65-9671a71a1a52",
+            IngestionId: "7792c4cd-d302-4747-b7f3-2b4f67547a91",
+            ProcessId: "Process"
+          },
+          RunMetadata: {
+            Status: "successWithWarnings",
+            NumberOfCases: 1000,
+            NumberOfRuns: 40
+          }
+        }
+      ]
+    }
+  }
+];
+function registerSimulationsCommand(program2) {
+  const simulationsCmd = program2.command("simulations").description("Read the process simulations (what-if scenarios) saved on a process app");
+  simulationsCmd.command("list <app-id>").description("List the simulations saved on a process app stage").addOption(new Option("--stage <stage>", "App stage").choices(STAGES8).default("dev")).examples(SIMULATIONS_LIST_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+    const config = await loadConfigOrExit();
+    if (!config)
+      return;
+    const [apiErr, result] = await catchError(pmtGet(config, appId, `/apps/${encodeURIComponent(appId)}/${options.stage}/simulations`));
+    if (apiErr) {
+      fail(apiErr.message, "Check the app id (uip pm apps list), that you have access to it, and that process simulation is enabled on this tenant.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: "Success",
+      Code: "PmSimulationsList",
+      Data: unwrapData(result)
+    });
+  });
 }
 
 // src/commands/transformations.ts
-var STAGES6 = ["dev", "published"];
+var STAGES9 = ["dev", "published"];
 var TRANSFORMATIONS_RUN_EXAMPLES = [
   {
     Description: "Rebuild a single dbt model and its dependents on dev",
@@ -7543,11 +9325,11 @@ var TRANSFORMATIONS_APPLY_EXAMPLES = [
 ];
 function registerTransformationsCommand(program2) {
   const transformationsCmd = program2.command("transformations").description("Work with the dbt SQL transformations of a process app");
-  transformationsCmd.command("list <app-id>").description("List the transformation files of a process app").addOption(new Option("--stage <stage>", "App stage to read from").choices(STAGES6).default("dev")).trackedAction(processContext, async (appId, options) => {
+  transformationsCmd.command("list <app-id>").description("List the transformation files of a process app").addOption(new Option("--stage <stage>", "App stage to read from").choices(STAGES9).default("dev")).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [apiErr, result] = await catchError2(pmGet(config, `/apps/${appId}/${options.stage}/transformation/tree`));
+    const [apiErr, result] = await catchError(pmGet(config, `/apps/${appId}/${options.stage}/transformation/tree`));
     if (apiErr) {
       fail(apiErr.message, "Check the app id (uip pm apps list) and your authentication.");
       return;
@@ -7558,17 +9340,17 @@ function registerTransformationsCommand(program2) {
       Data: result
     });
   });
-  transformationsCmd.command("get <app-id> <path>").description("Get the content of a transformation file, plus its ETag — which " + "`update` requires as --etag: it is what proves the edit was " + "based on this version").addOption(new Option("--stage <stage>", "App stage").choices(STAGES6).default("dev")).option("--destination <local-file>", "Write content to this local file instead of the output envelope").trackedAction(processContext, async (appId, path, options) => {
+  transformationsCmd.command("get <app-id> <path>").description("Get the content of a transformation file, plus its ETag — which " + "`update` requires as --etag: it is what proves the edit was " + "based on this version").addOption(new Option("--stage <stage>", "App stage").choices(STAGES9).default("dev")).option("--destination <local-file>", "Write content to this local file instead of the output envelope").trackedAction(processContext, async (appId, path2, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, file] = await catchError2(pmGetRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path}`));
+    const [err, file] = await catchError(pmGetRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path2}`));
     if (err) {
       fail(err.message, "Check the file path (uip pm transformations list).");
       return;
     }
     if (options.destination !== undefined) {
-      const [writeErr] = await catchError2(getFileSystem().writeFile(options.destination, file.content));
+      const [writeErr] = await catchError(getFileSystem().writeFile(options.destination, file.content));
       if (writeErr) {
         fail(writeErr.message, "Check the destination path and that the disk is writable.");
         return;
@@ -7578,28 +9360,28 @@ function registerTransformationsCommand(program2) {
       Result: "Success",
       Code: "PmTransformationsGet",
       Data: {
-        Path: path,
+        Path: path2,
         ETag: file.etag,
         ...options.destination !== undefined ? { Destination: options.destination } : { Content: file.content }
       }
     });
   });
-  transformationsCmd.command("update <app-id> <path>").description("Update a transformation file from a local file (ETag-safe) — pass " + "the --etag that `get` returned for the version you edited, so a " + "concurrent change is refused instead of overwritten").requiredOption("--file <local-file>", "Local file with the new content").requiredOption("--etag <etag>", "ETag of the file this edit is based on, as returned by " + "'uip pm transformations get'").addOption(new Option("--stage <stage>", "App stage").choices(STAGES6).default("dev")).examples(TRANSFORMATIONS_UPDATE_EXAMPLES).trackedAction(processContext, async (appId, path, options) => {
+  transformationsCmd.command("update <app-id> <path>").description("Update a transformation file from a local file (ETag-safe) — pass " + "the --etag that `get` returned for the version you edited, so a " + "concurrent change is refused instead of overwritten").requiredOption("--file <local-file>", "Local file with the new content").requiredOption("--etag <etag>", "ETag of the file this edit is based on, as returned by " + "'uip pm transformations get'").addOption(new Option("--stage <stage>", "App stage").choices(STAGES9).default("dev")).examples(TRANSFORMATIONS_UPDATE_EXAMPLES).trackedAction(processContext, async (appId, path2, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, etag] = await catchError2(updateFile(config, appId, path, options));
+    const [err, etag] = await catchError(updateFile(config, appId, path2, options));
     if (err) {
-      fail(err.message, isConflictError(err) ? conflictInstructions(`uip pm transformations get ${appId} ${path} --destination <file>`) : "Check the file path, and that --etag is the ETag " + `'uip pm transformations get ${appId} ${path}' returns.`);
+      fail(err.message, isConflictError(err) ? conflictInstructions(`uip pm transformations get ${appId} ${path2} --destination <file>`) : "Check the file path, and that --etag is the ETag " + `'uip pm transformations get ${appId} ${path2}' returns.`);
       return;
     }
     OutputFormatter.success({
       Result: "Success",
       Code: "PmTransformationsUpdate",
-      Data: { Path: path, ETag: etag }
+      Data: { Path: path2, ETag: etag }
     });
   });
-  transformationsCmd.command("create <app-id> <path>").description("Create a new transformation file from a local file " + "(use 'update' to modify an existing one)").requiredOption("--file <local-file>", "Local file with the new content").addOption(new Option("--stage <stage>", "App stage").choices(STAGES6).default("dev")).examples(TRANSFORMATIONS_CREATE_EXAMPLES).trackedAction(processContext, async (appId, path, options) => {
+  transformationsCmd.command("create <app-id> <path>").description("Create a new transformation file from a local file " + "(use 'update' to modify an existing one)").requiredOption("--file <local-file>", "Local file with the new content").addOption(new Option("--stage <stage>", "App stage").choices(STAGES9).default("dev")).examples(TRANSFORMATIONS_CREATE_EXAMPLES).trackedAction(processContext, async (appId, path2, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
@@ -7608,7 +9390,7 @@ function registerTransformationsCommand(program2) {
       fail(`Local file not found: ${options.file}`, "Check the --file path.");
       return;
     }
-    const [err, etag] = await catchError2(pmCreateRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path}?type=File`, String(content)));
+    const [err, etag] = await catchError(pmCreateRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path2}?type=File`, String(content)));
     if (err) {
       fail(err.message, "Check the app id and that the path does not already exist (use 'update' to modify an existing file).");
       return;
@@ -7616,7 +9398,7 @@ function registerTransformationsCommand(program2) {
     OutputFormatter.success({
       Result: "Success",
       Code: "PmTransformationsCreate",
-      Data: { Path: path, ETag: etag }
+      Data: { Path: path2, ETag: etag }
     });
   });
   transformationsCmd.command("run <app-id>").description("Run the dbt transformations on the dev stage").addOption(new Option("--stage <stage>", "App stage (only 'dev' supported)").choices(["dev"]).default("dev")).option("--model <model-path>", "Run only this model (e.g. 'models/Cases.sql') and its dependents").option("--wait", "Block until the build reaches a terminal state; exit non-zero on failure (auto-prints the dbt error)").option("--timeout <seconds>", "Max seconds to wait when --wait is set", "1800").option("--poll-interval <seconds>", "Seconds between status polls when --wait is set", "5").examples(TRANSFORMATIONS_RUN_EXAMPLES).trackedAction(processContext, async (appId, options) => {
@@ -7625,14 +9407,14 @@ function registerTransformationsCommand(program2) {
       return;
     let before = {};
     if (options.wait) {
-      const [readErr, snapshot] = await catchError2(readBuildStatus(config, appId));
+      const [readErr, snapshot] = await catchError(readBuildStatus(config, appId));
       if (readErr) {
         fail(readErr.message, "Check the app id (uip pm apps list) and your authentication.");
         return;
       }
       before = snapshot;
     }
-    const [err] = await catchError2(pmPost(config, `/apps/${appId}/${options.stage}/transformation/build`, options.model === undefined ? { type: 0 } : { type: 1, modelPath: options.model }));
+    const [err] = await catchError(pmPost(config, `/apps/${appId}/${options.stage}/transformation/build`, options.model === undefined ? { type: 0 } : { type: 1, modelPath: options.model }));
     if (err) {
       fail(err.message, "Check that data was ingested and no other build is running.");
       return;
@@ -7654,7 +9436,7 @@ function registerTransformationsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err] = await catchError2(pmPost(config, `/apps/${appId}/dev/transformation/build/cancel`));
+    const [err] = await catchError(pmPost(config, `/apps/${appId}/dev/transformation/build/cancel`));
     if (err) {
       fail(err.message, `Check the app id and that a build is running ('uip pm transformations status ${appId}').`);
       return;
@@ -7665,20 +9447,20 @@ function registerTransformationsCommand(program2) {
       Data: { AppId: appId, Status: "Cancelling" }
     });
   });
-  transformationsCmd.command("apply <app-id>").description("Re-run the full data transformation on already-ingested data " + "(unlike 'run', which builds only changed dev models)").addOption(new Option("--stage <stage>", "App stage").choices(STAGES6).default("dev")).option("--wait", "Block until the transform reaches a terminal state; exit non-zero on failure (auto-prints the dbt error)").option("--timeout <seconds>", "Max seconds to wait when --wait is set", "1800").option("--poll-interval <seconds>", "Seconds between status polls when --wait is set", "5").examples(TRANSFORMATIONS_APPLY_EXAMPLES).trackedAction(processContext, async (appId, options) => {
+  transformationsCmd.command("apply <app-id>").description("Re-run the full data transformation on already-ingested data " + "(unlike 'run', which builds only changed dev models)").addOption(new Option("--stage <stage>", "App stage").choices(STAGES9).default("dev")).option("--wait", "Block until the transform reaches a terminal state; exit non-zero on failure (auto-prints the dbt error)").option("--timeout <seconds>", "Max seconds to wait when --wait is set", "1800").option("--poll-interval <seconds>", "Seconds between status polls when --wait is set", "5").examples(TRANSFORMATIONS_APPLY_EXAMPLES).trackedAction(processContext, async (appId, options) => {
     const config = await loadConfigOrExit();
     if (!config)
       return;
     let before = {};
     if (options.wait) {
-      const [readErr, snapshot] = await catchError2(readLastIngestion(config, appId, options.stage));
+      const [readErr, snapshot] = await catchError(readLastIngestion(config, appId, options.stage));
       if (readErr) {
         fail(readErr.message, "Check the app id (uip pm apps list) and your authentication.");
         return;
       }
       before = snapshot;
     }
-    const [err] = await catchError2(pmPost(config, `/apps/${appId}/${options.stage}/transform`));
+    const [err] = await catchError(pmPost(config, `/apps/${appId}/${options.stage}/transform`));
     if (err) {
       fail(err.message, "Check the app id and that data has been ingested (uip pm apps list).");
       return;
@@ -7700,7 +9482,7 @@ function registerTransformationsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, result] = await catchError2(pmGet(config, `/apps/${appId}/dev/transformation/build/status`));
+    const [err, result] = await catchError(pmGet(config, `/apps/${appId}/dev/transformation/build/status`));
     if (err) {
       fail(err.message, "Check the app id.");
       return;
@@ -7715,7 +9497,7 @@ function registerTransformationsCommand(program2) {
     const config = await loadConfigOrExit();
     if (!config)
       return;
-    const [err, result] = await catchError2(pmGet(config, `/apps/${appId}/dev/transformation/build/logs`));
+    const [err, result] = await catchError(pmGet(config, `/apps/${appId}/dev/transformation/build/logs`));
     if (err) {
       fail(err.message, "Check the app id.");
       return;
@@ -7727,12 +9509,12 @@ function registerTransformationsCommand(program2) {
     });
   });
 }
-async function updateFile(config, appId, path, options) {
+async function updateFile(config, appId, path2, options) {
   const content = await getFileSystem().readFile(options.file, "utf-8");
   if (content === null) {
     throw new Error(`Local file not found: ${options.file}`);
   }
-  return pmPutRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path}?type=File`, String(content), options.etag);
+  return pmPutRaw(config, `/apps/${appId}/${options.stage}/transformation/tree/${path2}?type=File`, String(content), options.etag);
 }
 
 // src/tool.ts
@@ -7745,12 +9527,15 @@ var metadata = {
 var registerCommands = async (program2) => {
   registerAppsCommand(program2);
   registerAppTypesCommand(program2);
+  registerConformanceCommand(program2);
+  registerDeviationsCommand(program2);
   registerFilesCommand(program2);
   registerIngestionsCommand(program2);
   registerQueryCommand(program2);
+  registerSimulationsCommand(program2);
   registerTransformationsCommand(program2);
 };
 
 export { Command, metadata, registerCommands };
 
-//# debugId=A4B38AB33F0BCE0064756E2164756E21
+//# debugId=4E7CA921094D69AF64756E2164756E21