sim 2.1.6-preview.90.1 → 2.1.7-preview.92.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();
@@ -2714,11 +2716,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.`);
 }
@@ -2830,8 +2832,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);
@@ -2861,8 +2863,8 @@ 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) {
@@ -3036,16 +3038,16 @@ function redirectEndpoint(endpoint, requestPath, target) {
   return suggested === endpoint.replace(/\/+$/, "") ? null : suggested;
 }
 function pageProgress() {
-  let reported2 = false;
+  let reported = false;
   return {
     advance: (fetched) => {
       if (!process.stderr.isTTY)
         return;
-      reported2 = true;
+      reported = true;
       process.stderr.write(`\r${source_default.dim(`fetched ${fetched}…`)}\x1B[K`);
     },
     finish: () => {
-      if (reported2)
+      if (reported)
         process.stderr.write("\r\x1B[K");
     }
   };
@@ -6406,7 +6408,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
@@ -7049,13 +7051,6 @@ var V2_OPERATIONS = {
     responseMode: "json",
     summary: "Create Credential Connection",
     personalKeyOnly: true,
-    body: {
-      workspaceId: {
-        kind: "string",
-        required: true,
-        describe: "Workspace that will own the credential."
-      }
-    },
     opaqueBody: true
   },
   createCustomTool: {
@@ -13769,20 +13764,20 @@ 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 = 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 = 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")
@@ -13980,13 +13975,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)}`
@@ -14293,8 +14288,8 @@ function runFailureMessage(operation, payload) {
   const fallback = failureMessages[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) => {
@@ -14329,8 +14324,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)
@@ -14375,8 +14370,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);
   }
@@ -14550,7 +14545,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;
@@ -14613,8 +14608,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;
@@ -14632,10 +14627,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}
 `);
     }
   });
@@ -14651,7 +14646,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(" ");
@@ -14667,10 +14662,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;
@@ -14691,7 +14686,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];
@@ -14975,8 +14970,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);
@@ -15070,8 +15065,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
@@ -15112,11 +15107,11 @@ Examples:
     };
     const restorePipeHandling = streaming ? 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;
+        process.stdout.write(content);
       });
       if (!streaming) {
         printProtocolResult(profile.output, result);
@@ -15627,26 +15622,26 @@ ${dump(row, { lineWidth: 0, noRefs: true }).trimEnd()}`);
   return createTableWriter();
 }
 function followStatus() {
-  let reported2 = false;
+  let reported = false;
   return {
     note: (message) => {
       if (!process.stderr.isTTY)
         return;
-      reported2 = true;
+      reported = true;
       process.stderr.write(`\r${source_default.dim(message)}${ERASE_LINE}`);
     },
     warn: (message) => {
-      if (reported2) {
-        reported2 = false;
+      if (reported) {
+        reported = false;
         process.stderr.write(`\r${ERASE_LINE}`);
       }
       process.stderr.write(`warning: ${message}
 `);
     },
     clear: () => {
-      if (!reported2)
+      if (!reported)
         return;
-      reported2 = false;
+      reported = false;
       process.stderr.write(`\r${ERASE_LINE}`);
     }
   };
@@ -15934,18 +15929,18 @@ 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 (process.stderr.isTTY && line !== reported2) {
-      reported2 = line;
+    if (process.stderr.isTTY && line !== reported) {
+      reported = line;
       process.stderr.write(`\r${source_default.dim(line)}\x1B[K`);
     }
   }
-  if (process.stderr.isTTY && reported2 !== null)
+  if (process.stderr.isTTY && reported !== null)
     process.stderr.write("\r\x1B[K");
   return current;
 }
@@ -16132,16 +16127,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;
   }
@@ -16331,18 +16326,18 @@ 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 (!process.stderr.isTTY)
         return;
-      reported2 = true;
+      reported = true;
       process.stderr.write(`\r${source_default.dim(`${status} — waiting ${Math.round(elapsedMs / 1000)}s…`)}\x1B[K`);
     },
     finish: () => {
-      if (!reported2)
+      if (!reported)
         return;
-      reported2 = false;
+      reported = false;
       process.stderr.write("\r\x1B[K");
     }
   };
@@ -16410,16 +16405,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, {
@@ -16428,7 +16423,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",
@@ -16436,7 +16431,7 @@ function attachProtocolCommands(program2) {
     folders: "listKnowledgeFolders",
     createFolder: "createKnowledgeFolder"
   });
-  const tables = group(program2, "tables");
+  const tables = group(program, "tables");
   attachTableImport(tables);
   attachResourceDirectoryCommands(tables, {
     kind: "table",
@@ -16444,7 +16439,7 @@ function attachProtocolCommands(program2) {
     folders: "listTableFolders",
     createFolder: "createTableFolder"
   });
-  const workflows = group(program2, "workflows");
+  const workflows = group(program, "workflows");
   attachResourceDirectoryCommands(workflows, {
     kind: "workflow",
     resources: "listWorkflows",
@@ -16453,8 +16448,8 @@ function attachProtocolCommands(program2) {
   });
   attachWorkflowRunFollow(workflows);
   attachWorkflowRunWait(group(workflows, "runs"));
-  attachLogsFollow(group(program2, "logs"));
-  attachChat(program2);
+  attachLogsFollow(group(program, "logs"));
+  attachChat(program);
 }
 
 // src/terminal/secret-input.ts
@@ -16486,7 +16481,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);
@@ -16507,7 +16502,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;
@@ -16516,7 +16511,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") {
@@ -16528,7 +16523,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) {
@@ -16613,8 +16608,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;
@@ -16683,16 +16678,16 @@ function isProjectLocalInstall(modulePath, cwd) {
   const workingDirectory = normalizeModulePath(cwd).replace(/\/+$/, "");
   return workingDirectory === installRoot || workingDirectory.startsWith(`${installRoot}/`);
 }
-function isUnadvisableInstall(modulePath, env2, cwd) {
+function isUnadvisableInstall(modulePath, env, cwd) {
   const normalized = normalizeModulePath(modulePath);
-  return env2.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/packages/sim-cli/") || isProjectLocalInstall(modulePath, cwd);
+  return env.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/packages/sim-cli/") || isProjectLocalInstall(modulePath, cwd);
 }
 function normalizeModulePath(modulePath) {
   return modulePath.replace(/\\/g, "/").toLowerCase();
 }
-function registryUrl(env2) {
+function registryUrl(env) {
   const fallback = new URL(DIST_TAGS_PATH, DEFAULT_REGISTRY);
-  const configured = env2.npm_config_registry?.trim();
+  const configured = env.npm_config_registry?.trim();
   if (!configured)
     return fallback;
   try {
@@ -16743,16 +16738,16 @@ try {
 }
 `;
 function registryProcessEnv() {
-  const env2 = { ...process.env };
-  for (const key of Object.keys(env2)) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
     const normalized = key.toLowerCase();
     if (normalized === "npm_config_registry" || normalized === "sim_api_key")
-      delete env2[key];
+      delete env[key];
   }
-  return env2;
+  return env;
 }
 function requestRegistry(url, { headers, maxResponseBytes, timeoutMs }) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     const proxyArguments = process.execArgv.filter((argument) => argument === "--use-env-proxy" || argument === "--no-use-env-proxy");
     const child = spawn2(process.execPath, [...proxyArguments, "--input-type=module", "--eval", REGISTRY_REQUEST_SCRIPT], {
       env: registryProcessEnv(),
@@ -16780,24 +16775,24 @@ function requestRegistry(url, { headers, maxResponseBytes, timeoutMs }) {
     child.stdin.on("error", () => {});
     child.once("error", reject);
     child.once("close", (code) => {
-      resolve3(code === 0 && !failed ? Buffer.concat(chunks).toString("utf8") : null);
+      resolve(code === 0 && !failed ? Buffer.concat(chunks).toString("utf8") : null);
     });
     child.stdin.end(JSON.stringify({ headers, maxResponseBytes, timeoutMs, url: url.href }));
   });
 }
-async function fetchDistTags(env2, request) {
+async function fetchDistTags(env, request) {
   try {
-    const url = registryUrl(env2);
+    const url = registryUrl(env);
     if (!url)
       return null;
-    const text2 = await request(url, {
+    const text = await request(url, {
       headers: { accept: "application/json", "user-agent": `${PACKAGE_NAME}-cli/${CLI_VERSION}` },
       maxResponseBytes: MAX_RESPONSE_BYTES,
       timeoutMs: REGISTRY_TIMEOUT_MS
     });
-    if (text2 === null || Buffer.byteLength(text2) > MAX_RESPONSE_BYTES)
+    if (text === null || Buffer.byteLength(text) > MAX_RESPONSE_BYTES)
       return null;
-    const body = JSON.parse(text2);
+    const body = JSON.parse(text);
     if (typeof body !== "object" || body === null || Array.isArray(body))
       return null;
     const tags = {};
@@ -16883,7 +16878,7 @@ function isFresh(entry, now) {
   const age = now.getTime() - Date.parse(entry.checkedAt);
   return age >= 0 && age < CHECK_INTERVAL_MS;
 }
-function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env2 = process.env) {
+function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env = process.env) {
   const target = `${PACKAGE_NAME}@latest`;
   const normalized = normalizeModulePath(modulePath);
   if (normalized.includes(".bun/install/global"))
@@ -16894,7 +16889,7 @@ function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env2 = proc
   if (normalized.includes("/.yarn/") || normalized.includes("/yarn/")) {
     return `yarn global add ${target}`;
   }
-  const agent = env2.npm_config_user_agent ?? "";
+  const agent = env.npm_config_user_agent ?? "";
   if (agent.startsWith("pnpm/"))
     return `pnpm add -g ${target}`;
   if (agent.startsWith("yarn/"))
@@ -16905,18 +16900,18 @@ function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env2 = proc
 }
 async function announceUpdateIfAvailable(options = {}) {
   try {
-    const env2 = options.env ?? process.env;
+    const env = options.env ?? process.env;
     const isTty = options.isTty ?? process.stderr.isTTY === true;
     const modulePath = options.modulePath ?? fileURLToPath(import.meta.url);
     const cwd = options.cwd ?? process.cwd();
     const now = options.now ?? new Date;
-    if (isEnabled(env2.SIM_NO_UPDATE_CHECK))
+    if (isEnabled(env.SIM_NO_UPDATE_CHECK))
       return;
     if (!isTty)
       return;
-    if (CI_VARIABLES.some((variable) => isEnabled(env2[variable])))
+    if (CI_VARIABLES.some((variable) => isEnabled(env[variable])))
       return;
-    if (isUnadvisableInstall(modulePath, env2, cwd))
+    if (isUnadvisableInstall(modulePath, env, cwd))
       return;
     const currentVersion = options.currentVersion ?? CLI_VERSION;
     const current = parseStableVersion(currentVersion);
@@ -16926,7 +16921,7 @@ async function announceUpdateIfAvailable(options = {}) {
     const cached = readCache(cachePath);
     if (cached && isFresh(cached, now))
       return;
-    const tags = await fetchDistTags(env2, options.registryRequest ?? requestRegistry);
+    const tags = await fetchDistTags(env, options.registryRequest ?? requestRegistry);
     const latest = tags?.latest ?? null;
     const available = latest ? parseStableVersion(latest) : null;
     writeCache(cachePath, {
@@ -16938,7 +16933,7 @@ async function announceUpdateIfAvailable(options = {}) {
     if (!isNewerVersion(available, current))
       return;
     const write = options.write ?? ((message) => void process.stderr.write(message));
-    write(`Update available: sim ${currentVersion} → ${latest}. Run: ${upgradeCommand(modulePath, env2)}
+    write(`Update available: sim ${currentVersion} → ${latest}. Run: ${upgradeCommand(modulePath, env)}
 `);
   } catch {}
 }
@@ -16979,53 +16974,53 @@ 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(CLI_VERSION, "-V, --version [none]", "output the version number (takes no value)");
+  program.version(CLI_VERSION, "-V, --version [none]", "output the version number (takes no value)");
 }
 function buildProgram(options = {}) {
-  const program2 = new Command;
-  program2.name("sim").description(PROGRAM_DESCRIPTION);
+  const 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]));
-  program2.addCommand(loginCommand());
-  program2.addCommand(logoutCommand());
-  program2.addCommand(whoamiCommand());
-  program2.addCommand(profilesCommand());
-  program2.addCommand(configureCommand());
+    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]));
+  program.addCommand(loginCommand());
+  program.addCommand(logoutCommand());
+  program.addCommand(whoamiCommand());
+  program.addCommand(profilesCommand());
+  program.addCommand(configureCommand());
   for (const command of buildGeneratedCommands()) {
-    program2.addCommand(command);
-  }
-  attachCredentialCommands(program2);
-  attachProtocolCommands(program2);
-  attachSecretCommands(program2);
-  program2.addHelpText("after", HELP_EPILOGUE);
-  program2.hook("preAction", () => announceUpdateIfAvailable());
-  refuseHelpAfterUnknownCommand(program2);
-  assertNoReservedProgramFlags(program2);
-  return program2;
+    program.addCommand(command);
+  }
+  attachCredentialCommands(program);
+  attachProtocolCommands(program);
+  attachSecretCommands(program);
+  program.addHelpText("after", HELP_EPILOGUE);
+  program.hook("preAction", () => announceUpdateIfAvailable());
+  refuseHelpAfterUnknownCommand(program);
+  assertNoReservedProgramFlags(program);
+  return program;
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim",
-  "version": "2.1.6-preview.90.1",
+  "version": "2.1.7-preview.92.1",
   "description": "Sim CLI - talk to the Sim API from your terminal",
   "type": "module",
   "bin": {