sim 2.1.8-dev.94.1 → 2.1.8-dev.95.1

package/dist/index.js

@@ -19,13 +19,15 @@ var __toESM = (mod, isNodeMode, target) => {
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -34,7 +36,7 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../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);
@@ -58,7 +60,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 {
@@ -137,7 +139,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 {
@@ -148,7 +150,7 @@ var require_help = __commonJS((exports) => {
       this.showGlobalOptions = false;
     }
     visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+      const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
       if (cmd._hasImplicitHelpCommand()) {
         const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
         const helpCommand = cmd.createCommand(helpName).helpOption(false);
@@ -341,8 +343,8 @@ var require_help = __commonJS((exports) => {
           output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
         }
       }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+      const commandList = helper.visibleCommands(cmd).map((cmd) => {
+        return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
       });
       if (commandList.length > 0) {
         output = output.concat(["Commands:", formatList(commandList), ""]);
@@ -353,16 +355,16 @@ var require_help = __commonJS((exports) => {
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    wrap(str2, width, indent, minColumnWidth = 40) {
+    wrap(str, width, indent, minColumnWidth = 40) {
       const indents = " \\f\\t\\v   -   　\uFEFF";
       const manualIndent = new RegExp(`[\\n][${indents}]+`);
-      if (str2.match(manualIndent))
-        return str2;
+      if (str.match(manualIndent))
+        return str;
       const columnWidth = width - indent;
       if (columnWidth < minColumnWidth)
-        return str2;
-      const leadingStr = str2.slice(0, indent);
-      const columnText = str2.slice(indent).replace(`\r
+        return str;
+      const leadingStr = str.slice(0, indent);
+      const columnText = str.slice(indent).replace(`\r
 `, `
 `);
       const indentString = " ".repeat(indent);
@@ -384,7 +386,7 @@ var require_help = __commonJS((exports) => {
 });
 
 // ../../node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
+var require_option = __commonJS(function(exports) {
   var { InvalidArgumentError } = require_error();
 
   class Option {
@@ -512,9 +514,9 @@ var require_option = __commonJS((exports) => {
       return option.negate === (negativeValue === value);
     }
   }
-  function camelcase(str2) {
-    return str2.split("-").reduce((str3, word) => {
-      return str3 + word[0].toUpperCase() + word.slice(1);
+  function camelcase(str) {
+    return str.split("-").reduce((str, word) => {
+      return str + word[0].toUpperCase() + word.slice(1);
     });
   }
   function splitOptionFlags(flags) {
@@ -536,9 +538,9 @@ 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 editDistance2(a, b) {
+  function editDistance(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
       return Math.max(a.length, b.length);
     const d = [];
@@ -579,7 +581,7 @@ var require_suggestSimilar = __commonJS((exports) => {
     candidates.forEach((candidate) => {
       if (candidate.length <= 1)
         return;
-      const distance = editDistance2(word, candidate);
+      const distance = editDistance(word, candidate);
       const length = Math.max(word.length, candidate.length);
       const similarity = (length - distance) / length;
       if (similarity > minSimilarity) {
@@ -609,12 +611,12 @@ 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("events").EventEmitter;
   var childProcess = __require("child_process");
   var path = __require("path");
   var fs = __require("fs");
-  var process3 = __require("process");
+  var process2 = __require("process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
   var { Help } = require_help();
@@ -656,11 +658,11 @@ var require_command = __commonJS((exports) => {
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
       this._outputConfiguration = {
-        writeOut: (str2) => process3.stdout.write(str2),
-        writeErr: (str2) => process3.stderr.write(str2),
-        getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : undefined,
-        getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : undefined,
-        outputError: (str2, write) => write(str2)
+        writeOut: (str) => process2.stdout.write(str),
+        writeErr: (str) => process2.stderr.write(str),
+        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
+        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+        outputError: (str, write) => write(str)
       };
       this._hidden = false;
       this._hasHelpOption = true;
@@ -848,7 +850,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._exitCallback) {
         this._exitCallback(new CommanderError(exitCode, code, message));
       }
-      process3.exit(exitCode);
+      process2.exit(exitCode);
     }
     action(fn) {
       const listener = (args) => {
@@ -1010,35 +1012,35 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       return source;
     }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
+    _prepareUserArgs(argv2, parseOptions) {
+      if (argv2 !== undefined && !Array.isArray(argv2)) {
         throw new Error("first parameter to parse must be array or undefined");
       }
       parseOptions = parseOptions || {};
-      if (argv === undefined) {
-        argv = process3.argv;
-        if (process3.versions && process3.versions.electron) {
+      if (argv2 === undefined) {
+        argv2 = process2.argv;
+        if (process2.versions && process2.versions.electron) {
           parseOptions.from = "electron";
         }
       }
-      this.rawArgs = argv.slice();
+      this.rawArgs = argv2.slice();
       let userArgs;
       switch (parseOptions.from) {
         case undefined:
         case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
+          this._scriptPath = argv2[1];
+          userArgs = argv2.slice(2);
           break;
         case "electron":
-          if (process3.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
+          if (process2.defaultApp) {
+            this._scriptPath = argv2[1];
+            userArgs = argv2.slice(2);
           } else {
-            userArgs = argv.slice(1);
+            userArgs = argv2.slice(1);
           }
           break;
         case "user":
-          userArgs = argv.slice(0);
+          userArgs = argv2.slice(0);
           break;
         default:
           throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
@@ -1098,23 +1100,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       launchWithNode = sourceExt.includes(path.extname(executableFile));
       let proc;
-      if (process3.platform !== "win32") {
+      if (process2.platform !== "win32") {
         if (launchWithNode) {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-          proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
         } else {
           proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-        proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
       }
       if (!proc.killed) {
         const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
         signals.forEach((signal) => {
-          process3.on(signal, () => {
+          process2.on(signal, () => {
             if (proc.killed === false && proc.exitCode === null) {
               proc.kill(signal);
             }
@@ -1123,10 +1125,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       const exitCallback = this._exitCallback;
       if (!exitCallback) {
-        proc.on("close", process3.exit.bind(process3));
+        proc.on("close", process2.exit.bind(process2));
       } else {
         proc.on("close", () => {
-          exitCallback(new CommanderError(process3.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+          exitCallback(new CommanderError(process2.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
         });
       }
       proc.on("error", (err) => {
@@ -1141,7 +1143,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           throw new Error(`'${executableFile}' not executable`);
         }
         if (!exitCallback) {
-          process3.exit(1);
+          process2.exit(1);
         } else {
           const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
@@ -1491,11 +1493,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _parseOptionsEnv() {
       this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process3.env) {
+        if (option.envVar && option.envVar in process2.env) {
           const optionKey = option.attributeName();
           if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
             if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process3.env[option.envVar]);
+              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
             } else {
               this.emit(`optionEnv:${option.name()}`);
             }
@@ -1527,18 +1529,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.error(message, { code: "commander.missingMandatoryOptionValue" });
     }
     _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
+      const findBestOptionFromValue = (option) => {
+        const optionKey = option.attributeName();
         const optionValue = this.getOptionValue(optionKey);
         const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
         const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
         if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
           return negativeOption;
         }
-        return positiveOption || option2;
+        return positiveOption || option;
       };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
+      const getErrorMessage = (option) => {
+        const bestOption = findBestOptionFromValue(option);
         const optionKey = bestOption.attributeName();
         const source = this.getOptionValueSource(optionKey);
         if (source === "env") {
@@ -1590,35 +1592,35 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const message = `error: unknown command '${unknownName}'${suggestion}`;
       this.error(message, { code: "commander.unknownCommand" });
     }
-    version(str2, flags, description) {
-      if (str2 === undefined)
+    version(str, flags, description) {
+      if (str === undefined)
         return this._version;
-      this._version = str2;
+      this._version = str;
       flags = flags || "-V, --version";
       description = description || "output the version number";
       const versionOption = this.createOption(flags, description);
       this._versionOptionName = versionOption.attributeName();
       this.options.push(versionOption);
       this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str2}
+        this._outputConfiguration.writeOut(`${str}
 `);
-        this._exit(0, "commander.version", str2);
+        this._exit(0, "commander.version", str);
       });
       return this;
     }
-    description(str2, argsDescription) {
-      if (str2 === undefined && argsDescription === undefined)
+    description(str, argsDescription) {
+      if (str === undefined && argsDescription === undefined)
         return this._description;
-      this._description = str2;
+      this._description = str;
       if (argsDescription) {
         this._argsDescription = argsDescription;
       }
       return this;
     }
-    summary(str2) {
-      if (str2 === undefined)
+    summary(str) {
+      if (str === undefined)
         return this._summary;
-      this._summary = str2;
+      this._summary = str;
       return this;
     }
     alias(alias) {
@@ -1639,8 +1641,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       aliases.forEach((alias) => this.alias(alias));
       return this;
     }
-    usage(str2) {
-      if (str2 === undefined) {
+    usage(str) {
+      if (str === undefined) {
         if (this._usage)
           return this._usage;
         const args = this.registeredArguments.map((arg) => {
@@ -1648,23 +1650,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
         });
         return [].concat(this.options.length || this._hasHelpOption ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
       }
-      this._usage = str2;
+      this._usage = str;
       return this;
     }
-    name(str2) {
-      if (str2 === undefined)
+    name(str) {
+      if (str === undefined)
         return this._name;
-      this._name = str2;
+      this._name = str;
       return this;
     }
     nameFromFilename(filename) {
       this._name = path.basename(filename, path.extname(filename));
       return this;
     }
-    executableDir(path2) {
-      if (path2 === undefined)
+    executableDir(path) {
+      if (path === undefined)
         return this._executableDir;
-      this._executableDir = path2;
+      this._executableDir = path;
       return this;
     }
     helpInformation(contextOptions) {
@@ -1724,13 +1726,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process3.exitCode || 0;
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
+      let exitCode2 = process2.exitCode || 0;
+      if (exitCode2 === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+        exitCode2 = 1;
       }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
+      this._exit(exitCode2, "commander.help", "(outputHelp)");
     }
-    addHelpText(position, text2) {
+    addHelpText(position, text) {
       const allowedValues = ["beforeAll", "before", "after", "afterAll"];
       if (!allowedValues.includes(position)) {
         throw new Error(`Unexpected value for position to addHelpText.
@@ -1739,10 +1741,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const helpEvent = `${position}Help`;
       this.on(helpEvent, (context) => {
         let helpStr;
-        if (typeof text2 === "function") {
-          helpStr = text2({ error: context.error, command: context.command });
+        if (typeof text === "function") {
+          helpStr = text({ error: context.error, command: context.command });
         } else {
-          helpStr = text2;
+          helpStr = text;
         }
         if (helpStr) {
           context.write(`${helpStr}
@@ -1792,7 +1794,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 });
 
 // ../../node_modules/commander/index.js
-var require_commander = __commonJS((exports, module) => {
+var require_commander = __commonJS(function(exports, module) {
   var { Argument } = require_argument();
   var { Command } = require_command();
   var { CommanderError, InvalidArgumentError } = require_error();
@@ -2314,6 +2316,14 @@ function setSoftExitCode(code) {
     process.exitCode = code;
 }
 var embedStore = new AsyncLocalStorage;
+
+class EmbeddedExit extends Error {
+  code;
+  constructor(code) {
+    super(`CLI exited with code ${code}`);
+    this.code = code;
+  }
+}
 function embeddedProfile() {
   const ctx = embedStore.getStore();
   if (!ctx)
@@ -2329,6 +2339,11 @@ function embeddedProfile() {
     sources: { endpoint: "flag", apiKey: "flag", workspaceId: "flag", output: "flag" }
   };
 }
+function exitCli(code) {
+  if (embedStore.getStore())
+    throw new EmbeddedExit(code);
+  return process.exit(code);
+}
 
 // src/output/presentation.ts
 var plain = new Chalk({ level: 0 });
@@ -2722,6 +2737,39 @@ function resolveProfile(overrides = {}) {
     }
   };
 }
+// src/output/io.ts
+import { format } from "node:util";
+function printLine(...args) {
+  const context = embedStore.getStore();
+  if (context)
+    context.stdout.write(`${format(...args)}
+`);
+  else
+    console.log(...args);
+}
+function printError(...args) {
+  const context = embedStore.getStore();
+  if (context)
+    context.stderr.write(`${format(...args)}
+`);
+  else
+    console.error(...args);
+}
+function writeStdout(chunk) {
+  const context = embedStore.getStore();
+  if (!context)
+    return process.stdout.write(chunk);
+  context.stdout.write(chunk);
+  return true;
+}
+function writeStderr(chunk) {
+  const context = embedStore.getStore();
+  if (!context)
+    return process.stderr.write(chunk);
+  context.stderr.write(chunk);
+  return true;
+}
+
 // src/version.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 function readPackageVersion() {
@@ -2748,7 +2796,7 @@ function once(key, message) {
   if (reported.has(key))
     return;
   reported.add(key);
-  process.stderr.write(`warning: ${message}
+  writeStderr(`warning: ${message}
 `);
 }
 var PROXY_VARIABLES = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
@@ -2763,11 +2811,11 @@ function runtimeCanProxy(version) {
     return minor >= firstSupportedMinor;
   return major > FIRST_SUPPORTED_MAJOR;
 }
-function warnIfProxyIgnored(env2 = process.env, version = process.version) {
-  const variable = PROXY_VARIABLES.find((name) => env2[name]);
+function warnIfProxyIgnored(env = process.env, version = process.version) {
+  const variable = PROXY_VARIABLES.find((name) => env[name]);
   if (!variable)
     return;
-  if (env2.NODE_USE_ENV_PROXY && runtimeCanProxy(version))
+  if (env.NODE_USE_ENV_PROXY && runtimeCanProxy(version))
     return;
   once("proxy", runtimeCanProxy(version) ? `${variable} is set but Node only uses it when NODE_USE_ENV_PROXY=1. Re-run with NODE_USE_ENV_PROXY=1 to route through the proxy.` : `${variable} is set but Node ${version} cannot use it. Upgrade to Node 22.21 or 24.5 and set NODE_USE_ENV_PROXY=1 to route through the proxy.`);
 }
@@ -2879,8 +2927,8 @@ var RAISE_TIMEOUT_HINT = "Raise SIM_TIMEOUT_SECONDS, or set it to 0 to wait inde
 function isRequestTimeout(error) {
   return error instanceof DOMException && error.name === "TimeoutError";
 }
-function resolveTimeoutMs(env2 = process.env) {
-  const raw = env2.SIM_TIMEOUT_SECONDS;
+function resolveTimeoutMs(env = process.env) {
+  const raw = env.SIM_TIMEOUT_SECONDS;
   if (raw === undefined || raw.trim() === "")
     return DEFAULT_TIMEOUT_SECONDS * 1000;
   const seconds = Number(raw);
@@ -2910,12 +2958,12 @@ function combineSignals(caller, timeout) {
   }
   return controller.signal;
 }
-function debugEnabled(env2 = process.env) {
-  const raw = env2.SIM_DEBUG;
+function debugEnabled(env = process.env) {
+  const raw = env.SIM_DEBUG;
   return raw !== undefined && raw !== "" && raw !== "0" && raw.toLowerCase() !== "false";
 }
 function traceRequest(method, url, status, startedAt) {
-  process.stderr.write(`${styles3().dim(`[sim] ${method} ${url} → ${status} ${Math.round(performance.now() - startedAt)}ms`)}
+  writeStderr(`${styles3().dim(`[sim] ${method} ${url} → ${status} ${Math.round(performance.now() - startedAt)}ms`)}
 `);
 }
 function withoutLeadingLabel(message, label) {
@@ -3088,17 +3136,17 @@ function redirectEndpoint(endpoint, requestPath, target) {
   return suggested === endpoint.replace(/\/+$/, "") ? null : suggested;
 }
 function pageProgress() {
-  let reported2 = false;
+  let reported = false;
   return {
     advance: (fetched) => {
       if (!hasProgressTerminal())
         return;
-      reported2 = true;
-      process.stderr.write(`\r${styles3().dim(`fetched ${fetched}…`)}\x1B[K`);
+      reported = true;
+      writeStderr(`\r${styles3().dim(`fetched ${fetched}…`)}\x1B[K`);
     },
     finish: () => {
-      if (reported2)
-        process.stderr.write("\r\x1B[K");
+      if (reported)
+        writeStderr("\r\x1B[K");
     }
   };
 }
@@ -5771,14 +5819,14 @@ function requireDumper() {
     let hasFoldableLine = false;
     const shouldTrackWidth = lineWidth !== -1;
     let previousLineBreak = -1;
-    let plain2 = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
+    let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
     if (singleLineOnly || forceQuotes) {
       for (i = 0;i < string.length; char >= 65536 ? i += 2 : i++) {
         char = codePointAt(string, i);
         if (!isPrintable(char)) {
           return STYLE_DOUBLE;
         }
-        plain2 = plain2 && isPlainSafe(char, prevChar, inblock);
+        plain = plain && isPlainSafe(char, prevChar, inblock);
         prevChar = char;
       }
     } else {
@@ -5793,13 +5841,13 @@ function requireDumper() {
         } else if (!isPrintable(char)) {
           return STYLE_DOUBLE;
         }
-        plain2 = plain2 && isPlainSafe(char, prevChar, inblock);
+        plain = plain && isPlainSafe(char, prevChar, inblock);
         prevChar = char;
       }
       hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ");
     }
     if (!hasLineBreak && !hasFoldableLine) {
-      if (plain2 && !forceQuotes && !testAmbiguousType(string)) {
+      if (plain && !forceQuotes && !testAmbiguousType(string)) {
         return STYLE_PLAIN;
       }
       return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
@@ -6361,8 +6409,8 @@ function visibleWidth(value) {
   return displayWidth(value);
 }
 function stripAnsi(value) {
-  const plain2 = value.replace(ANSI_PATTERN, "");
-  return plain2 === EMPTY_GLYPH ? "" : plain2;
+  const plain = value.replace(ANSI_PATTERN, "");
+  return plain === EMPTY_GLYPH ? "" : plain;
 }
 function pad(value, width) {
   return value + " ".repeat(Math.max(0, width - visibleWidth(value)));
@@ -6399,36 +6447,36 @@ function renderMachine(format, raw) {
 function printList(format, rows, columns, raw = rows) {
   const machine = renderMachine(format, raw);
   if (machine !== null) {
-    console.log(machine);
+    printLine(machine);
     return;
   }
   if (format === "text") {
     for (const row of rows) {
-      console.log(columns.map((column) => oneLine(stripAnsi(column.value(row)))).join("\t"));
+      printLine(columns.map((column) => oneLine(stripAnsi(column.value(row)))).join("\t"));
     }
     return;
   }
-  console.log(renderTable(rows, columns));
+  printLine(renderTable(rows, columns));
 }
 function printDocument(format, raw) {
-  console.log(format === "yaml" ? renderMachine("yaml", raw) : JSON.stringify(raw, null, 2));
+  printLine(format === "yaml" ? renderMachine("yaml", raw) : JSON.stringify(raw, null, 2));
 }
 function printRecord(format, fields, raw) {
   const machine = renderMachine(format, raw);
   if (machine !== null) {
-    console.log(machine);
+    printLine(machine);
     return;
   }
   const safeFields = fields.map(([label, value]) => [safeOneLine(label), value]);
   if (format === "text") {
     for (const [label, value] of safeFields) {
-      console.log(`${label}	${oneLine(stripAnsi(value))}`);
+      printLine(`${label}	${oneLine(stripAnsi(value))}`);
     }
     return;
   }
   const width = Math.max(...safeFields.map(([label]) => visibleWidth(label)));
   for (const [label, value] of safeFields) {
-    console.log(`${styles3().dim(pad(`${label}:`, width + 1))}  ${clamp(oneLine(value), MAX_RECORD_WIDTH)}`);
+    printLine(`${styles3().dim(pad(`${label}:`, width + 1))}  ${clamp(oneLine(value), MAX_RECORD_WIDTH)}`);
   }
 }
 
@@ -6457,7 +6505,7 @@ import { createHash, randomBytes, randomInt } from "node:crypto";
 
 // src/helpers.ts
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/auth/device-flow.ts
@@ -6535,7 +6583,7 @@ async function pollForKey(endpoint, auth, signal) {
       consecutiveTransportFailures++;
       if (!warnedAboutTransport && consecutiveTransportFailures >= TRANSPORT_FAILURES_BEFORE_WARNING) {
         warnedAboutTransport = true;
-        process.stderr.write(`Still waiting: ${endpoint} is not answering the login poll (${cause.message}). Check the endpoint; retrying until you approve or the login times out.
+        writeStderr(`Still waiting: ${endpoint} is not answering the login poll (${cause.message}). Check the endpoint; retrying until you approve or the login times out.
 `);
       }
     }
@@ -11705,10 +11753,10 @@ async function chooseWorkspace(client) {
   if (workspaces.length > MAX_INTERACTIVE_WORKSPACES) {
     throw new SimApiError(`The active API key can access more than ${MAX_INTERACTIVE_WORKSPACES} workspaces, which is too many to show interactively. Pass --workspace <id> instead.`, 0);
   }
-  console.log(`
+  printLine(`
 Available workspaces:`);
   for (const [index, workspace] of workspaces.entries()) {
-    console.log(`  ${index + 1}) ${safeOneLine(workspace.name)} (${workspace.id})`);
+    printLine(`  ${index + 1}) ${safeOneLine(workspace.name)} (${workspace.id})`);
   }
   const prompt = createInterface({ input: process.stdin, output: process.stderr });
   try {
@@ -11733,10 +11781,10 @@ function addProfileCommand() {
       auth_profile: authProfile,
       workspace: normalizeWorkspaceId(workspace.id, "the workspace response")
     });
-    console.log(styles3().green(`✓ Added profile "${safeOneLine(profileName)}" in ${configPath()}`));
-    console.log(`  Workspace: ${safeOneLine(workspace.name)} (${workspace.id})`);
-    console.log(`  Authentication: ${safeOneLine(authProfile)}`);
-    console.log(styles3().dim(`  Try: sim --profile ${safeOneLine(profileName)} whoami`));
+    printLine(styles3().green(`✓ Added profile "${safeOneLine(profileName)}" in ${configPath()}`));
+    printLine(`  Workspace: ${safeOneLine(workspace.name)} (${workspace.id})`);
+    printLine(`  Authentication: ${safeOneLine(authProfile)}`);
+    printLine(styles3().dim(`  Try: sim --profile ${safeOneLine(profileName)} whoami`));
   });
 }
 function loginCommand() {
@@ -11753,21 +11801,21 @@ function loginCommand() {
     if (readCredentialsProfile(profile.name).api_key && !options.yes) {
       const confirmed = await confirmProfileOverwrite(profile.name);
       if (!confirmed) {
-        console.log(styles3().dim("Login cancelled; the existing profile was not changed."));
+        printLine(styles3().dim("Login cancelled; the existing profile was not changed."));
         return;
       }
     }
     const auth = createAuthRequest();
     const url = buildApprovalUrl(profile.endpoint, auth, scope, profile.workspaceId ?? undefined);
-    console.log(`Signing in to ${styles3().bold(profile.endpoint)} as profile ${styles3().bold(safeOneLine(profile.name))}`);
-    console.log(`
+    printLine(`Signing in to ${styles3().bold(profile.endpoint)} as profile ${styles3().bold(safeOneLine(profile.name))}`);
+    printLine(`
 Pairing code: ${styles3().bold(auth.pairing)}`);
-    console.log(styles3().dim(`Confirm this code matches what the browser shows before approving.
+    printLine(styles3().dim(`Confirm this code matches what the browser shows before approving.
 `));
-    console.log(url);
+    printLine(url);
     if (options.browser)
       openBrowser(url);
-    console.log(styles3().dim(`
+    printLine(styles3().dim(`
 Waiting for approval…`));
     const key = await pollForKey(profile.endpoint, auth);
     if (key.scope !== scope) {
@@ -11780,14 +11828,14 @@ Waiting for approval…`));
     requireStorableKey(key.apiKey);
     writeConfigProfile(profile.name, settings);
     writeCredentialsProfile(profile.name, key.apiKey);
-    console.log(styles3().green(`
+    printLine(styles3().green(`
 ✓ Logged in. Key stored in ${credentialsPath()}`));
     if (key.workspaceBound && key.workspaceId) {
-      console.log(styles3().dim(`  Workspace-scoped key — it can only reach ${key.workspaceId}.`));
+      printLine(styles3().dim(`  Workspace-scoped key — it can only reach ${key.workspaceId}.`));
     } else if (key.workspaceId) {
-      console.log(styles3().dim(`  Personal key, defaulting to ${key.workspaceId}. Override per command with --workspace.`));
+      printLine(styles3().dim(`  Personal key, defaulting to ${key.workspaceId}. Override per command with --workspace.`));
     } else {
-      console.log(styles3().dim("  Personal key with no default workspace. Set one with: sim configure --set-workspace <id>"));
+      printLine(styles3().dim("  Personal key with no default workspace. Set one with: sim configure --set-workspace <id>"));
     }
   });
 }
@@ -11801,10 +11849,10 @@ function logoutCommand() {
       }
       const removed = deleteProfile(profileName);
       if (!removed.config && !removed.credentials) {
-        console.log(styles3().dim(`Nothing stored for profile "${safeOneLine(profileName)}".`));
+        printLine(styles3().dim(`Nothing stored for profile "${safeOneLine(profileName)}".`));
         return;
       }
-      console.log(styles3().green(`✓ Removed profile "${safeOneLine(profileName)}".`));
+      printLine(styles3().green(`✓ Removed profile "${safeOneLine(profileName)}".`));
       return;
     }
     const profile = profileFrom(command);
@@ -11813,12 +11861,12 @@ function logoutCommand() {
       throw new SimApiError(`Profile "${redact(profile.name)}" shares authentication with "${redact(authProfile)}". Log out of the authentication profile instead: sim logout --profile ${redact(authProfile)}`, 0);
     }
     if (!readCredentialsProfile(profile.name).api_key) {
-      console.log(styles3().dim(`No stored key for profile "${safeOneLine(profile.name)}".`));
+      printLine(styles3().dim(`No stored key for profile "${safeOneLine(profile.name)}".`));
       return;
     }
     writeCredentialsProfile(profile.name, null);
-    console.log(styles3().green(`✓ Removed the stored key for profile "${safeOneLine(profile.name)}".`));
-    console.log(styles3().dim("  The key itself is still active — revoke it in Settings → Sim API keys."));
+    printLine(styles3().green(`✓ Removed the stored key for profile "${safeOneLine(profile.name)}".`));
+    printLine(styles3().dim("  The key itself is still active — revoke it in Settings → Sim API keys."));
   });
 }
 async function readKeyType(client) {
@@ -11998,7 +12046,7 @@ function profilesCommand() {
     const rows = listProfiles().map((name) => buildProfileRow(name, name === activeName));
     if (rows.length === 0) {
       if (output === "table")
-        console.log(styles3().dim("No profiles yet. Run: sim login"));
+        printLine(styles3().dim("No profiles yet. Run: sim login"));
       else
         printList(output, rows, PROFILE_COLUMNS);
       return;
@@ -12078,21 +12126,21 @@ function configureCommand() {
     if (Object.keys(updates).length === 0) {
       const current = readConfigProfile(profile.name);
       if (Object.keys(current).length === 0) {
-        console.log(styles3().dim(`No settings stored for profile "${profile.name}".`));
+        printLine(styles3().dim(`No settings stored for profile "${profile.name}".`));
         return;
       }
       for (const [key, value] of Object.entries(current)) {
-        console.log(`${styles3().dim(`${key}:`)} ${value}`);
+        printLine(`${styles3().dim(`${key}:`)} ${value}`);
       }
       return;
     }
     const removalOnly = Object.values(updates).every((value) => value === null);
     if (removalOnly && Object.keys(readConfigProfile(profile.name)).length === 0) {
-      console.log(styles3().dim(`No settings stored for profile "${profile.name}".`));
+      printLine(styles3().dim(`No settings stored for profile "${profile.name}".`));
       return;
     }
     writeConfigProfile(profile.name, updates);
-    console.log(styles3().green(`✓ Updated profile "${profile.name}" in ${configPath()}`));
+    printLine(styles3().green(`✓ Updated profile "${profile.name}" in ${configPath()}`));
   });
 }
 
@@ -13341,13 +13389,13 @@ async function localFile(path, override) {
     embedded.identity.signal?.throwIfAborted();
     if (!embedded.openFile)
       throw new SimApiError("This invocation has no machine to read from", 0);
-    const { size: size2 } = await embedded.openFile(embeddedFileKey(path));
+    const { size } = await embedded.openFile(embeddedFileKey(path));
     embedded.identity.signal?.throwIfAborted();
-    if (!Number.isSafeInteger(size2) || size2 < 0)
+    if (!Number.isSafeInteger(size) || size < 0)
       throw new SimApiError("Invalid file size", 0);
-    if (size2 === 0)
+    if (size === 0)
       throw new SimApiError(`${path} is empty`, 0);
-    return { name: override ?? basename(embeddedFileKey(path)), size: size2 };
+    return { name: override ?? basename(embeddedFileKey(path)), size };
   }
   let size;
   try {
@@ -13647,20 +13695,20 @@ async function buildRequest(operation, positional, flags, workspaceId) {
   const headerSlot = Object.keys(headers).length > 0 ? { headers } : {};
   if (spec.opaqueBody) {
     if (commandSpec.bodyVariants) {
-      const provided = commandSpec.bodyVariants.filter((variant2) => flags[camel(variant2.name)] !== undefined);
-      const names = commandSpec.bodyVariants.map((variant2) => `--${variant2.name}`).join(" or ");
+      const provided = commandSpec.bodyVariants.filter((variant) => flags[camel(variant.name)] !== undefined);
+      const names = commandSpec.bodyVariants.map((variant) => `--${variant.name}`).join(" or ");
       if (provided.length !== 1) {
         throw new SimApiError(`Pass exactly one of ${names}`, 0);
       }
       const variant = provided[0];
-      const raw2 = flags[camel(variant.name)];
-      if (typeof raw2 !== "string")
+      const raw = flags[camel(variant.name)];
+      if (typeof raw !== "string")
         throw new SimApiError(`--${variant.name} is required`, 0);
-      const parsed2 = await coerce(raw2, { kind: variant.kind }, { json: true }, variant.name);
-      if (variant.kind === "object" && (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) || variant.kind === "array" && !Array.isArray(parsed2)) {
+      const parsed = await coerce(raw, { kind: variant.kind }, { json: true }, variant.name);
+      if (variant.kind === "object" && (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) || variant.kind === "array" && !Array.isArray(parsed)) {
         throw new SimApiError(`--${variant.name} must be a JSON ${variant.kind}`, 0);
       }
-      return { path, query, body: { ...body, [variant.property]: parsed2 }, ...headerSlot };
+      return { path, query, body: { ...body, [variant.property]: parsed }, ...headerSlot };
     }
     const raw = flags.body;
     if (typeof raw !== "string")
@@ -13789,7 +13837,7 @@ function warn(kind, from, to) {
   if (warned.has(key))
     return;
   warned.add(key);
-  process.stderr.write(`warning: ${kind} "${from}" has been renamed to "${to}". The old name still works.
+  writeStderr(`warning: ${kind} "${from}" has been renamed to "${to}". The old name still works.
 `);
 }
 function warnRenamedCommand(from, to) {
@@ -13857,13 +13905,13 @@ function renderSpan(value, depth) {
   const indent = "  ".repeat(depth);
   const detailIndent = `${indent}  `;
   const name = requiredText(span, "name");
-  const type2 = requiredText(span, "type");
+  const type = requiredText(span, "type");
   const status = optionalText(span, "status");
   const elapsed = optionalNumber(span, "durationMs") ?? optionalNumber(span, "duration");
   const totalCost = costTotal(span);
   const summary = [
     `${indent}- ${name}`,
-    `[${type2}]`,
+    `[${type}]`,
     status,
     elapsed === undefined ? undefined : duration(Math.round(elapsed)),
     totalCost === undefined ? undefined : `$${totalCost.toFixed(4)}`
@@ -13901,13 +13949,13 @@ function renderSpan(value, depth) {
 function printTraceSpans(format, traceSpans) {
   if (format === "json" || format === "yaml")
     return;
-  console.log("");
-  console.log(format === "table" ? styles3().dim("trace:") : "trace:");
+  printLine("");
+  printLine(format === "table" ? styles3().dim("trace:") : "trace:");
   if (traceSpans.length === 0) {
-    console.log(styles3().dim("  No trace spans."));
+    printLine(styles3().dim("  No trace spans."));
     return;
   }
-  console.log(traceSpans.flatMap((span) => renderSpan(span, 0)).join(`
+  printLine(traceSpans.flatMap((span) => renderSpan(span, 0)).join(`
 `));
 }
 
@@ -14072,7 +14120,7 @@ function writePageNote(spec, envelope) {
   const value = at(envelope, spec.pageNote.path);
   if (value === undefined || value === null)
     return;
-  process.stderr.write(styles3().dim(`${spec.pageNote.label}: ${String(value)}
+  writeStderr(styles3().dim(`${spec.pageNote.label}: ${String(value)}
 `));
 }
 var TRUNCATION_FLAG = /^truncated$|^[A-Za-z0-9]+Truncated$/;
@@ -14105,14 +14153,14 @@ function clippedSubject(flag) {
 }
 function writeEnvelopeTruncation(envelope) {
   for (const flag of responseTruncationFlags(envelope)) {
-    process.stderr.write(styles3().dim(`${spellOut(flag)}: the server clipped ${clippedSubject(flag)}, so the answer is incomplete
+    writeStderr(styles3().dim(`${spellOut(flag)}: the server clipped ${clippedSubject(flag)}, so the answer is incomplete
 `));
   }
 }
 function writeCursorTruncation(count, truncated) {
   if (!truncated)
     return;
-  process.stderr.write(styles3().dim(`showing the first ${count}; more results exist — re-run with --limit 0 for all
+  writeStderr(styles3().dim(`showing the first ${count}; more results exist — re-run with --limit 0 for all
 `));
 }
 function renderResult(operation, format, raw, spec, options = {}, envelope) {
@@ -14165,8 +14213,8 @@ function runFailureMessage(operation, payload) {
   const fallback = FAILED_RUN_STATUS_MESSAGES[status];
   if (!fallback)
     return null;
-  const reported2 = error?.message;
-  return safeOneLine(typeof reported2 === "string" && reported2 ? reported2 : fallback);
+  const reported = error?.message;
+  return safeOneLine(typeof reported === "string" && reported ? reported : fallback);
 }
 var BULK_OUTCOME_CHECKS = {
   bulkDeleteFiles: (payload, body) => {
@@ -14201,8 +14249,8 @@ var BULK_OUTCOME_CHECKS = {
     const requested = lengthOf(body?.chunkIds);
     if (requested === 0)
       return null;
-    const reported2 = payload.errors?.[0];
-    return typeof reported2 === "string" && reported2 ? safeOneLine(reported2) : `Updated nothing: none of the ${requested} requested ${requested === 1 ? "chunk" : "chunks"} matched.`;
+    const reported = payload.errors?.[0];
+    return typeof reported === "string" && reported ? safeOneLine(reported) : `Updated nothing: none of the ${requested} requested ${requested === 1 ? "chunk" : "chunks"} matched.`;
   },
   deleteTableRows: (payload) => {
     if (countOf(payload.deletedCount) > 0)
@@ -14248,7 +14296,7 @@ function writeResultNote(operation, payload, body) {
   const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
   const message = note(record, body);
   if (message)
-    process.stderr.write(styles3().dim(`${message}
+    writeStderr(styles3().dim(`${message}
 `));
 }
 function bulkFailureMessage(operation, payload, body) {
@@ -14263,8 +14311,8 @@ var EXCLUSIVE_CAP_FIELDS = {
   deleteTableRows: { cap: "limit", ids: "rowIds" }
 };
 function readPagedLimit(raw) {
-  const text2 = String(raw ?? DEFAULT_LIMIT).trim();
-  const value = text2 === "" ? Number.NaN : Number(text2);
+  const text = String(raw ?? DEFAULT_LIMIT).trim();
+  const value = text === "" ? Number.NaN : Number(text);
   if (!Number.isInteger(value) || value < 0) {
     throw new SimApiError("--limit must be a whole number of 0 or more (0 for everything)", 0);
   }
@@ -14439,7 +14487,7 @@ function retypeMessage(message, spellings) {
 }
 function retypeDetails(details, spellings) {
   if (Array.isArray(details))
-    return details.map((issue2) => retypeDetails(issue2, spellings));
+    return details.map((issue) => retypeDetails(issue, spellings));
   if (!details || typeof details !== "object")
     return details;
   const issue = details;
@@ -14501,8 +14549,8 @@ function commandPath(command) {
   return names.join(" ");
 }
 var UNKNOWN_OPTION_TOKEN = /^error: unknown option '(.+?)'/;
-function looksLikeAnId(token2) {
-  return token2.length > 2 && !token2.startsWith("--") && /^-[A-Za-z0-9_-]*[A-Z0-9][A-Za-z0-9_-]*$/.test(token2);
+function looksLikeAnId(token) {
+  return token.length > 2 && !token.startsWith("--") && /^-[A-Za-z0-9_-]*[A-Z0-9][A-Za-z0-9_-]*$/.test(token);
 }
 function addArgumentExamples(command) {
   const outputError = command.configureOutput().outputError;
@@ -14520,10 +14568,10 @@ function addArgumentExamples(command) {
       }
       if (command.registeredArguments.length === 0)
         return;
-      const token2 = UNKNOWN_OPTION_TOKEN.exec(message)?.[1];
-      if (!token2 || !looksLikeAnId(token2))
+      const token = UNKNOWN_OPTION_TOKEN.exec(message)?.[1];
+      if (!token || !looksLikeAnId(token))
         return;
-      write(`Example: ${commandPath(command)} -- ${token2}
+      write(`Example: ${commandPath(command)} -- ${token}
 `);
     }
   });
@@ -14539,7 +14587,7 @@ function assertNoReservedFlags(command, operation) {
   }
 }
 var RESERVED_FLAG_EXEMPTIONS = new Set(["profiles add"]);
-function assertNoReservedProgramFlags(program2) {
+function assertNoReservedProgramFlags(program) {
   const walk = (command, prefix) => {
     const path = [...prefix, command.name()];
     const name = path.join(" ");
@@ -14555,10 +14603,10 @@ function assertNoReservedProgramFlags(program2) {
     for (const child of command.commands)
       walk(child, path);
   };
-  for (const child of program2.commands)
+  for (const child of program.commands)
     walk(child, []);
 }
-function refuseHelpAfterUnknownCommand(program2) {
+function refuseHelpAfterUnknownCommand(program) {
   const walk = (command) => {
     const internals = command;
     const dispatchesOnly = command.commands.length > 0 && !internals._actionHandler && command.registeredArguments.length === 0;
@@ -14579,7 +14627,7 @@ function refuseHelpAfterUnknownCommand(program2) {
     for (const child of command.commands)
       walk(child);
   };
-  walk(program2);
+  walk(program);
 }
 function configureOperation(command, operation, spec) {
   const operationSpec = V2_OPERATIONS[operation];
@@ -14863,8 +14911,8 @@ function acceptNameOnUpdate(credentials) {
     options.displayName = options.name;
   });
 }
-function attachCredentialCommands(program2) {
-  const credentials = program2.commands.find((command) => command.name() === "credentials");
+function attachCredentialCommands(program) {
+  const credentials = program.commands.find((command) => command.name() === "credentials");
   if (!credentials)
     throw new Error("The generated credentials command group is missing");
   acceptNameOnUpdate(credentials);
@@ -14958,8 +15006,8 @@ function ignoreBrokenPipe(stream) {
     stream.off("error", onError);
   };
 }
-function attachChat(program2) {
-  program2.command("chat").description("Ask Sim and print the reply").argument("<message>", "What to ask Sim").allowExcessArguments(false).option("-c, --conversation <id>", "Continue the conversation with this ID").addHelpText("after", `
+function attachChat(program) {
+  program.command("chat").description("Ask Sim and print the reply").argument("<message>", "What to ask Sim").allowExcessArguments(false).option("-c, --conversation <id>", "Continue the conversation with this ID").addHelpText("after", `
 Each turn prints the reply on stdout and the conversation ID on stderr; pass
 that ID back with -c to continue the same conversation. With --output json or
 yaml the reply is not streamed — the finished result is printed as one
@@ -14992,19 +15040,19 @@ Examples:
     const endStreamedLine = () => {
       if (streamed.length > 0 && !streamed.endsWith(`
 `)) {
-        process.stdout.write(`
+        writeStdout(`
 `);
         streamed += `
 `;
       }
     };
-    const restorePipeHandling = streaming ? ignoreBrokenPipe(process.stdout) : undefined;
+    const restorePipeHandling = streaming && !embedStore.getStore() ? ignoreBrokenPipe(process.stdout) : undefined;
     try {
-      const result = await readChatStream(response, (content2) => {
+      const result = await readChatStream(response, (content) => {
         if (!streaming)
           return;
-        streamed += content2;
-        process.stdout.write(content2);
+        streamed += content;
+        writeStdout(content);
       });
       if (!streaming) {
         printProtocolResult(profile.output, result);
@@ -15012,11 +15060,11 @@ Examples:
       }
       const content = sanitize(result.content ?? "");
       if (content.startsWith(streamed) && content.length > streamed.length) {
-        process.stdout.write(content.slice(streamed.length));
+        writeStdout(content.slice(streamed.length));
         streamed = content;
       }
       endStreamedLine();
-      process.stderr.write(`${styles3().dim(`conversation: ${result.conversationId}`)}
+      writeStderr(`${styles3().dim(`conversation: ${result.conversationId}`)}
 `);
     } catch (error) {
       endStreamedLine();
@@ -15163,15 +15211,19 @@ async function saveToFile(body, target, force) {
   }
   return saveStagedFile(body, target, force);
 }
-async function streamToStdout(body, output = process.stdout) {
+async function streamToStdout(body, output) {
   const reader = body.getReader();
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done)
         return;
-      if (!output.write(value))
-        await once2(output, "drain");
+      if (output) {
+        if (!output.write(value))
+          await once2(output, "drain");
+      } else if (!writeStdout(value)) {
+        await once2(process.stdout, "drain");
+      }
     }
   } finally {
     await reader.cancel().catch(() => {});
@@ -15574,11 +15626,11 @@ function createTableWriter() {
     if (!widths) {
       widths = COLUMNS.map((column, index) => Math.min(MAX_CELL_WIDTH2, Math.max(column.floor, visibleWidth(column.header), ...lines.map((line) => visibleWidth(line[index])))));
       const header = widths;
-      console.log(styles3().dim(COLUMNS.map((column, index) => pad2(column.header.toUpperCase(), header[index])).join("  ").trimEnd()));
+      printLine(styles3().dim(COLUMNS.map((column, index) => pad2(column.header.toUpperCase(), header[index])).join("  ").trimEnd()));
     }
     const locked = widths;
     for (const line of lines) {
-      console.log(line.map((cell, index) => pad2(cell, locked[index])).join("  ").trimEnd());
+      printLine(line.map((cell, index) => pad2(cell, locked[index])).join("  ").trimEnd());
     }
   };
 }
@@ -15586,13 +15638,13 @@ function createWriter(format) {
   if (format === "json") {
     return (rows) => {
       for (const row of rows)
-        console.log(JSON.stringify(row));
+        printLine(JSON.stringify(row));
     };
   }
   if (format === "yaml") {
     return (rows) => {
       for (const row of rows) {
-        console.log(`---
+        printLine(`---
 ${dump(row, { lineWidth: 0, noRefs: true }).trimEnd()}`);
       }
     };
@@ -15606,27 +15658,27 @@ ${dump(row, { lineWidth: 0, noRefs: true }).trimEnd()}`);
   return createTableWriter();
 }
 function followStatus() {
-  let reported2 = false;
+  let reported = false;
   return {
     note: (message) => {
       if (!hasProgressTerminal())
         return;
-      reported2 = true;
-      process.stderr.write(`\r${styles3().dim(message)}${ERASE_LINE}`);
+      reported = true;
+      writeStderr(`\r${styles3().dim(message)}${ERASE_LINE}`);
     },
     warn: (message) => {
-      if (reported2) {
-        reported2 = false;
-        process.stderr.write(`\r${ERASE_LINE}`);
+      if (reported) {
+        reported = false;
+        writeStderr(`\r${ERASE_LINE}`);
       }
-      process.stderr.write(`warning: ${message}
+      writeStderr(`warning: ${message}
 `);
     },
     clear: () => {
-      if (!reported2)
+      if (!reported)
         return;
-      reported2 = false;
-      process.stderr.write(`\r${ERASE_LINE}`);
+      reported = false;
+      writeStderr(`\r${ERASE_LINE}`);
     }
   };
 }
@@ -15913,19 +15965,19 @@ function progressLine(job) {
 }
 async function watchImport(client, workspaceId, job) {
   let current = job;
-  let reported2 = null;
+  let reported = null;
   while (!IMPORT_SETTLED.has(current.status)) {
     await sleep2(IMPORT_POLL_MS);
     const next = await client.request(`/api/v2/tables/imports/${encodeURIComponent(current.id)}`, { query: { workspaceId } });
     current = next.data;
     const line = progressLine(current);
-    if (hasProgressTerminal() && line !== reported2) {
-      reported2 = line;
-      process.stderr.write(`\r${styles3().dim(line)}\x1B[K`);
+    if (hasProgressTerminal() && line !== reported) {
+      reported = line;
+      writeStderr(`\r${styles3().dim(line)}\x1B[K`);
     }
   }
-  if (hasProgressTerminal() && reported2 !== null)
-    process.stderr.write("\r\x1B[K");
+  if (hasProgressTerminal() && reported !== null)
+    writeStderr("\r\x1B[K");
   return current;
 }
 function validateTargetOptions(options) {
@@ -16108,16 +16160,16 @@ class Commentary {
   constructor(sink) {
     this.sink = sink;
   }
-  inline(text2) {
-    if (text2.length === 0)
+  inline(text) {
+    if (text.length === 0)
       return;
-    this.sink.write(text2);
-    this.atLineStart = text2.endsWith(`
+    this.sink.write(text);
+    this.atLineStart = text.endsWith(`
 `);
   }
-  line(text2) {
+  line(text) {
     this.sink.write(`${this.atLineStart ? "" : `
-`}${text2}
+`}${text}
 `);
     this.atLineStart = true;
   }
@@ -16225,7 +16277,7 @@ async function followRun(workflowId, command) {
   const final = await renderRunStream(response.body, {
     includeThinking,
     includeToolCalls,
-    stderr: process.stderr
+    stderr: { write: writeStderr }
   });
   renderResult("executeWorkflow", profile.output, final, CLI_CONTRACT.executeWorkflow ?? {});
   if (final.success === false) {
@@ -16422,19 +16474,19 @@ function classify(snapshot) {
   return snapshot.status === "completed" ? "completed" : snapshot.status === "cancelled" ? "cancelled" : "failed";
 }
 function waitProgress() {
-  let reported2 = false;
+  let reported = false;
   return {
     advance: (status, elapsedMs) => {
       if (!hasProgressTerminal())
         return;
-      reported2 = true;
-      process.stderr.write(`\r${styles3().dim(`${status} — waiting ${Math.round(elapsedMs / 1000)}s…`)}\x1B[K`);
+      reported = true;
+      writeStderr(`\r${styles3().dim(`${status} — waiting ${Math.round(elapsedMs / 1000)}s…`)}\x1B[K`);
     },
     finish: () => {
-      if (!reported2)
+      if (!reported)
         return;
-      reported2 = false;
-      process.stderr.write("\r\x1B[K");
+      reported = false;
+      writeStderr("\r\x1B[K");
     }
   };
 }
@@ -16478,7 +16530,7 @@ function attachWorkflowRunWait(runs) {
           renderResult("getWorkflowRun", profile.output, runData(raw), runSpec());
           const message = explain(outcome, runId, options.workflow, snapshot);
           if (message)
-            console.error(styles3().red(message));
+            printError(styles3().red(message));
           setSoftExitCode(WAIT_EXIT_CODES[outcome]);
           return;
         }
@@ -16486,7 +16538,7 @@ function attachWorkflowRunWait(runs) {
         if (remainingMs <= 0) {
           progress.finish();
           renderResult("getWorkflowRun", profile.output, runData(raw), runSpec());
-          console.error(styles3().red(`Timed out after ${timeoutSeconds}s waiting for run ${runId} (status: ${snapshot.status}${snapshot.resumeAt ? `, resuming at ${snapshot.resumeAt}` : ""}). Raise ${WAIT_TIMEOUT_FLAG}, or set it to 0 to wait indefinitely.`));
+          printError(styles3().red(`Timed out after ${timeoutSeconds}s waiting for run ${runId} (status: ${snapshot.status}${snapshot.resumeAt ? `, resuming at ${snapshot.resumeAt}` : ""}). Raise ${WAIT_TIMEOUT_FLAG}, or set it to 0 to wait indefinitely.`));
           setSoftExitCode(WAIT_EXIT_CODES.timeout);
           return;
         }
@@ -16501,16 +16553,16 @@ function attachWorkflowRunWait(runs) {
 }
 
 // src/commands/protocol/index.ts
-function group(program2, name) {
-  const existing = program2.commands.find((command) => command.name() === name);
+function group(program, name) {
+  const existing = program.commands.find((command) => command.name() === name);
   if (existing)
     return existing;
   const created = new Command(name);
-  program2.addCommand(created);
+  program.addCommand(created);
   return created;
 }
-function attachProtocolCommands(program2) {
-  const files = group(program2, "files");
+function attachProtocolCommands(program) {
+  const files = group(program, "files");
   attachFileUpload(files);
   attachFileGet(files);
   attachResourceDirectoryCommands(files, {
@@ -16519,7 +16571,7 @@ function attachProtocolCommands(program2) {
     folders: "listFileFolders",
     createFolder: "createFileFolder"
   });
-  const knowledge = group(program2, "knowledge");
+  const knowledge = group(program, "knowledge");
   attachKnowledgeDocumentUpload(group(knowledge, "documents"));
   attachResourceDirectoryCommands(knowledge, {
     kind: "knowledge",
@@ -16527,7 +16579,7 @@ function attachProtocolCommands(program2) {
     folders: "listKnowledgeFolders",
     createFolder: "createKnowledgeFolder"
   });
-  const tables = group(program2, "tables");
+  const tables = group(program, "tables");
   attachTableImport(tables);
   attachResourceDirectoryCommands(tables, {
     kind: "table",
@@ -16535,7 +16587,7 @@ function attachProtocolCommands(program2) {
     folders: "listTableFolders",
     createFolder: "createTableFolder"
   });
-  const workflows = group(program2, "workflows");
+  const workflows = group(program, "workflows");
   attachResourceDirectoryCommands(workflows, {
     kind: "workflow",
     resources: "listWorkflows",
@@ -16546,8 +16598,8 @@ function attachProtocolCommands(program2) {
   const runs = group(workflows, "runs");
   attachWorkflowRunGet(runs);
   attachWorkflowRunWait(runs);
-  attachLogsFollow(group(program2, "logs"));
-  attachChat(program2);
+  attachLogsFollow(group(program, "logs"));
+  attachChat(program);
 }
 
 // src/terminal/secret-input.ts
@@ -16579,7 +16631,7 @@ function promptSecret(input = process.stdin, output = process.stderr) {
   emitKeypressEvents(input);
   input.setRawMode(true);
   input.resume();
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     const cleanup = () => {
       input.removeListener("keypress", onKeypress);
       input.setRawMode(wasRaw);
@@ -16600,7 +16652,7 @@ function promptSecret(input = process.stdin, output = process.stderr) {
     };
     const fail = (message) => finish(() => reject(new SimApiError(message, 0)));
     const cancel = () => finish(() => reject(new SecretInputCancelledError));
-    function onKeypress(text2, key) {
+    function onKeypress(text, key) {
       if (key.ctrl && (key.name === "c" || key.name === "d")) {
         cancel();
         return;
@@ -16609,7 +16661,7 @@ function promptSecret(input = process.stdin, output = process.stderr) {
         if (value.length === 0)
           fail("Secret value cannot be empty.");
         else
-          finish(() => resolve3(value));
+          finish(() => resolve(value));
         return;
       }
       if (key.name === "backspace") {
@@ -16621,7 +16673,7 @@ function promptSecret(input = process.stdin, output = process.stderr) {
         }
         return;
       }
-      const entered = text2 || metaCharacter(key);
+      const entered = text || metaCharacter(key);
       if (!entered || key.ctrl || key.name === "escape")
         return;
       if (value.length + entered.length > MAX_SECRET_LENGTH) {
@@ -16681,8 +16733,8 @@ async function readSecretValue(options) {
   } catch (error) {
     if (!(error instanceof SecretInputCancelledError))
       throw error;
-    console.error(styles3().red(`Error: ${error.message}`));
-    return process.exit(CANCELLED_EXIT_CODE);
+    printError(styles3().red(`Error: ${error.message}`));
+    return exitCli(CANCELLED_EXIT_CODE);
   }
 }
 async function setSecret(name, options, command, redactionSpellings) {
@@ -16706,8 +16758,8 @@ async function setSecret(name, options, command, redactionSpellings) {
   });
   renderResult("setSecret", profile.output, response.data, SECRET_RESULT);
 }
-function attachSecretCommands(program2) {
-  const secrets = program2.commands.find((command) => command.name() === "secrets");
+function attachSecretCommands(program) {
+  const secrets = program.commands.find((command) => command.name() === "secrets");
   if (!secrets)
     throw new Error("The generated secrets command group is missing");
   const redactionSpellings = new Set;
@@ -16750,37 +16802,37 @@ var ROOT_VALUE_FLAGS = new Set([
 function namesASubcommandFirst(rawArgs) {
   const tokens = rawArgs.slice(2);
   for (let index = 0;index < tokens.length; index += 1) {
-    const token2 = tokens[index];
-    if (token2 === "--version" || token2 === "-V")
+    const token = tokens[index];
+    if (token === "--version" || token === "-V")
       return false;
-    if (ROOT_VALUE_FLAGS.has(token2)) {
+    if (ROOT_VALUE_FLAGS.has(token)) {
       index += 1;
       continue;
     }
-    if (token2.startsWith("-"))
+    if (token.startsWith("-"))
       continue;
     return true;
   }
   return false;
 }
-function addVersionOption(program2) {
-  program2.on("option:version", (value) => {
+function addVersionOption(program) {
+  program.on("option:version", (value) => {
     if (value === null || value === undefined) {
-      const { rawArgs } = program2;
+      const { rawArgs } = program;
       if (!namesASubcommandFirst(rawArgs ?? []))
         return;
-      program2.error("error: --version reports the Sim CLI version and is not a command flag. A command that acts on a deployment version reads it from --to-version.");
+      program.error("error: --version reports the Sim CLI version and is not a command flag. A command that acts on a deployment version reads it from --to-version.");
     }
-    program2.error("error: --version reports the Sim CLI version and takes no value. A command that acts on a deployment version reads it from --to-version.");
+    program.error("error: --version reports the Sim CLI version and takes no value. A command that acts on a deployment version reads it from --to-version.");
   });
-  program2.version(cliVersion(), "-V, --version [none]", "output the version number (takes no value)");
+  program.version(cliVersion(), "-V, --version [none]", "output the version number (takes no value)");
 }
 function buildProgram(options = {}) {
-  const program2 = options.program ?? new Command;
-  program2.name("sim").description(PROGRAM_DESCRIPTION);
+  const program = options.program ?? new Command;
+  program.name("sim").description(PROGRAM_DESCRIPTION);
   if (options.version !== false)
-    addVersionOption(program2);
-  program2.option("-P, --profile <name>", "Profile to use (env: SIM_PROFILE)").option("--endpoint <url>", "Sim deployment to talk to (env: SIM_ENDPOINT)").option("-w, --workspace <id>", "Workspace to target (env: SIM_WORKSPACE)").addOption(new Option("--output <format>", "Output format for this command").choices([...OUTPUT_FORMATS]));
+    addVersionOption(program);
+  program.option("-P, --profile <name>", "Profile to use (env: SIM_PROFILE)").option("--endpoint <url>", "Sim deployment to talk to (env: SIM_ENDPOINT)").option("-w, --workspace <id>", "Workspace to target (env: SIM_WORKSPACE)").addOption(new Option("--output <format>", "Output format for this command").choices([...OUTPUT_FORMATS]));
   for (const command of [
     loginCommand,
     logoutCommand,
@@ -16788,23 +16840,23 @@ function buildProgram(options = {}) {
     profilesCommand,
     configureCommand
   ])
-    program2.addCommand(command());
+    program.addCommand(command());
   for (const command of buildGeneratedCommands()) {
-    program2.addCommand(command);
+    program.addCommand(command);
   }
-  attachCredentialCommands(program2);
-  attachProtocolCommands(program2);
-  attachSecretCommands(program2);
-  program2.addHelpText("after", options.helpText ?? HELP_EPILOGUE);
-  refuseHelpAfterUnknownCommand(program2);
-  assertNoReservedProgramFlags(program2);
-  return program2;
+  attachCredentialCommands(program);
+  attachProtocolCommands(program);
+  attachSecretCommands(program);
+  program.addHelpText("after", options.helpText ?? HELP_EPILOGUE);
+  refuseHelpAfterUnknownCommand(program);
+  assertNoReservedProgramFlags(program);
+  return program;
 }
 
 // src/terminal.ts
-async function runTerminalCli(program2 = buildProgram()) {
+async function runTerminalCli(program = buildProgram()) {
   try {
-    await program2.parseAsync(process.argv);
+    await program.parseAsync(process.argv);
   } catch (error) {
     if (error instanceof ProfileConfigError) {
       console.error(styles3().red(`Error: ${sanitize(error.message)}`));