@remixhq/claude-plugin 0.1.8 → 0.1.9

package/dist/{hook-stop-collab.js → hook-stop-collab.cjs}

@@ -1,17 +1,12 @@
 #!/usr/bin/env node
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a2, b) => (typeof require !== "undefined" ? require : a2)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -37,11 +32,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // node_modules/isexe/windows.js
 var require_windows = __commonJS({
-  "node_modules/isexe/windows.js"(exports, module) {
+  "node_modules/isexe/windows.js"(exports2, module2) {
     "use strict";
-    module.exports = isexe;
+    module2.exports = isexe;
     isexe.sync = sync;
-    var fs8 = __require("fs");
+    var fs8 = require("fs");
     function checkPathExt(path12, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -78,11 +73,11 @@ var require_windows = __commonJS({
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS({
-  "node_modules/isexe/mode.js"(exports, module) {
+  "node_modules/isexe/mode.js"(exports2, module2) {
     "use strict";
-    module.exports = isexe;
+    module2.exports = isexe;
     isexe.sync = sync;
-    var fs8 = __require("fs");
+    var fs8 = require("fs");
     function isexe(path12, options, cb) {
       fs8.stat(path12, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
@@ -112,16 +107,16 @@ var require_mode = __commonJS({
 
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
-  "node_modules/isexe/index.js"(exports, module) {
+  "node_modules/isexe/index.js"(exports2, module2) {
     "use strict";
-    var fs8 = __require("fs");
+    var fs8 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
     } else {
       core = require_mode();
     }
-    module.exports = isexe;
+    module2.exports = isexe;
     isexe.sync = sync;
     function isexe(path12, options, cb) {
       if (typeof options === "function") {
@@ -168,10 +163,10 @@ var require_isexe = __commonJS({
 
 // node_modules/which/which.js
 var require_which = __commonJS({
-  "node_modules/which/which.js"(exports, module) {
+  "node_modules/which/which.js"(exports2, module2) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path12 = __require("path");
+    var path12 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -258,14 +253,14 @@ var require_which = __commonJS({
         return null;
       throw getNotFoundError(cmd);
     };
-    module.exports = which;
+    module2.exports = which;
     which.sync = whichSync;
   }
 });
 
 // node_modules/path-key/index.js
 var require_path_key = __commonJS({
-  "node_modules/path-key/index.js"(exports, module) {
+  "node_modules/path-key/index.js"(exports2, module2) {
     "use strict";
     var pathKey2 = (options = {}) => {
       const environment = options.env || process.env;
@@ -275,16 +270,16 @@ var require_path_key = __commonJS({
       }
       return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
     };
-    module.exports = pathKey2;
-    module.exports.default = pathKey2;
+    module2.exports = pathKey2;
+    module2.exports.default = pathKey2;
   }
 });
 
 // node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS({
-  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
     "use strict";
-    var path12 = __require("path");
+    var path12 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -318,13 +313,13 @@ var require_resolveCommand = __commonJS({
     function resolveCommand(parsed) {
       return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
     }
-    module.exports = resolveCommand;
+    module2.exports = resolveCommand;
   }
 });
 
 // node_modules/cross-spawn/lib/util/escape.js
 var require_escape = __commonJS({
-  "node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+  "node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
     "use strict";
     var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
     function escapeCommand(arg) {
@@ -342,25 +337,25 @@ var require_escape = __commonJS({
       }
       return arg;
     }
-    module.exports.command = escapeCommand;
-    module.exports.argument = escapeArgument;
+    module2.exports.command = escapeCommand;
+    module2.exports.argument = escapeArgument;
   }
 });
 
 // node_modules/shebang-regex/index.js
 var require_shebang_regex = __commonJS({
-  "node_modules/shebang-regex/index.js"(exports, module) {
+  "node_modules/shebang-regex/index.js"(exports2, module2) {
     "use strict";
-    module.exports = /^#!(.*)/;
+    module2.exports = /^#!(.*)/;
   }
 });
 
 // node_modules/shebang-command/index.js
 var require_shebang_command = __commonJS({
-  "node_modules/shebang-command/index.js"(exports, module) {
+  "node_modules/shebang-command/index.js"(exports2, module2) {
     "use strict";
     var shebangRegex = require_shebang_regex();
-    module.exports = (string = "") => {
+    module2.exports = (string = "") => {
       const match = string.match(shebangRegex);
       if (!match) {
         return null;
@@ -377,9 +372,9 @@ var require_shebang_command = __commonJS({
 
 // node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS({
-  "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+  "node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
     "use strict";
-    var fs8 = __require("fs");
+    var fs8 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -393,15 +388,15 @@ var require_readShebang = __commonJS({
       }
       return shebangCommand(buffer.toString());
     }
-    module.exports = readShebang;
+    module2.exports = readShebang;
   }
 });
 
 // node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS({
-  "node_modules/cross-spawn/lib/parse.js"(exports, module) {
+  "node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
     "use strict";
-    var path12 = __require("path");
+    var path12 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -455,13 +450,13 @@ var require_parse = __commonJS({
       };
       return options.shell ? parsed : parseNonShell(parsed);
     }
-    module.exports = parse;
+    module2.exports = parse;
   }
 });
 
 // node_modules/cross-spawn/lib/enoent.js
 var require_enoent = __commonJS({
-  "node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+  "node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
     "use strict";
     var isWin = process.platform === "win32";
     function notFoundError(original, syscall) {
@@ -500,7 +495,7 @@ var require_enoent = __commonJS({
       }
       return null;
     }
-    module.exports = {
+    module2.exports = {
       hookChildProcess,
       verifyENOENT,
       verifyENOENTSync,
@@ -511,9 +506,9 @@ var require_enoent = __commonJS({
 
 // node_modules/cross-spawn/index.js
 var require_cross_spawn = __commonJS({
-  "node_modules/cross-spawn/index.js"(exports, module) {
+  "node_modules/cross-spawn/index.js"(exports2, module2) {
     "use strict";
-    var cp = __require("child_process");
+    var cp = require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
     function spawn2(command, args, options) {
@@ -528,11 +523,11 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn2;
-    module.exports.spawn = spawn2;
-    module.exports.sync = spawnSync2;
-    module.exports._parse = parse;
-    module.exports._enoent = enoent;
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
+    module2.exports.sync = spawnSync2;
+    module2.exports._parse = parse;
+    module2.exports._enoent = enoent;
   }
 });
 
@@ -551,14 +546,14 @@ var RemixError = class extends Error {
 };
 
 // node_modules/@remixhq/core/dist/chunk-FAZUMWBS.js
-import fs2 from "fs/promises";
-import path2 from "path";
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
 function getCollabBindingPath(repoRoot) {
-  return path2.join(repoRoot, ".remix", "config.json");
+  return import_path.default.join(repoRoot, ".remix", "config.json");
 }
 async function readCollabBinding(repoRoot) {
   try {
-    const raw = await fs2.readFile(getCollabBindingPath(repoRoot), "utf8");
+    const raw = await import_promises.default.readFile(getCollabBindingPath(repoRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.schemaVersion !== 1) return null;
     if (!parsed.projectId || !parsed.currentAppId || !parsed.upstreamAppId) return null;
@@ -588,10 +583,10 @@ var REMIX_ERROR_CODES = {
 };
 
 // node_modules/@remixhq/core/dist/chunk-UGKPOCN5.js
-import fs from "fs/promises";
-import { createHash } from "crypto";
-import os from "os";
-import path7 from "path";
+var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_crypto = require("crypto");
+var import_os = __toESM(require("os"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
 // node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -603,7 +598,7 @@ function isPlainObject(value) {
 }
 
 // node_modules/execa/lib/arguments/file-url.js
-import { fileURLToPath } from "url";
+var import_node_url = require("url");
 var safeNormalizeFileUrl = (file, name) => {
   const fileString = normalizeFileUrl(normalizeDenoExecPath(file));
   if (typeof fileString !== "string") {
@@ -613,7 +608,7 @@ var safeNormalizeFileUrl = (file, name) => {
 };
 var normalizeDenoExecPath = (file) => isDenoExecPath(file) ? file.toString() : file;
 var isDenoExecPath = (file) => typeof file !== "string" && file && Object.getPrototypeOf(file) === String.prototype;
-var normalizeFileUrl = (file) => file instanceof URL ? fileURLToPath(file) : file;
+var normalizeFileUrl = (file) => file instanceof URL ? (0, import_node_url.fileURLToPath)(file) : file;
 
 // node_modules/execa/lib/methods/parameters.js
 var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
@@ -637,10 +632,10 @@ var normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
 };
 
 // node_modules/execa/lib/methods/template.js
-import { ChildProcess } from "child_process";
+var import_node_child_process = require("child_process");
 
 // node_modules/execa/lib/utils/uint-array.js
-import { StringDecoder } from "string_decoder";
+var import_node_string_decoder = require("string_decoder");
 var { toString: objectToString } = Object.prototype;
 var isArrayBuffer = (value) => objectToString.call(value) === "[object ArrayBuffer]";
 var isUint8Array = (value) => objectToString.call(value) === "[object Uint8Array]";
@@ -657,7 +652,7 @@ var uint8ArraysToStrings = (uint8ArraysOrStrings, encoding) => {
   if (encoding === "utf8" && uint8ArraysOrStrings.every((uint8ArrayOrString) => typeof uint8ArrayOrString === "string")) {
     return uint8ArraysOrStrings;
   }
-  const decoder = new StringDecoder(encoding);
+  const decoder = new import_node_string_decoder.StringDecoder(encoding);
   const strings = uint8ArraysOrStrings.map((uint8ArrayOrString) => typeof uint8ArrayOrString === "string" ? stringToUint8Array(uint8ArrayOrString) : uint8ArrayOrString).map((uint8Array) => decoder.write(uint8Array));
   const finalString = decoder.end();
   return finalString === "" ? strings : [...strings, finalString];
@@ -768,7 +763,7 @@ var parseExpression = (expression) => {
   if (isPlainObject(expression) && ("stdout" in expression || "isMaxBuffer" in expression)) {
     return getSubprocessResult(expression);
   }
-  if (expression instanceof ChildProcess || Object.prototype.toString.call(expression) === "[object Promise]") {
+  if (expression instanceof import_node_child_process.ChildProcess || Object.prototype.toString.call(expression) === "[object Promise]") {
     throw new TypeError("Unexpected subprocess in template expression. Please use ${await subprocess} instead of ${subprocess}.");
   }
   throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
@@ -787,15 +782,15 @@ var getSubprocessResult = ({ stdout }) => {
 };
 
 // node_modules/execa/lib/methods/main-sync.js
-import { spawnSync } from "child_process";
+var import_node_child_process3 = require("child_process");
 
 // node_modules/execa/lib/arguments/specific.js
-import { debuglog } from "util";
+var import_node_util = require("util");
 
 // node_modules/execa/lib/utils/standard-stream.js
-import process2 from "process";
+var import_node_process = __toESM(require("process"), 1);
 var isStandardStream = (stream) => STANDARD_STREAMS.includes(stream);
-var STANDARD_STREAMS = [process2.stdin, process2.stdout, process2.stderr];
+var STANDARD_STREAMS = [import_node_process.default.stdin, import_node_process.default.stdout, import_node_process.default.stderr];
 var STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
 var getStreamName = (fdNumber) => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
 
@@ -858,7 +853,7 @@ var parseFd = (fdName) => {
 };
 var FD_REGEXP = /^fd(\d+)$/;
 var addDefaultValue = (optionArray, optionName) => optionArray.map((optionValue) => optionValue === void 0 ? DEFAULT_OPTIONS[optionName] : optionValue);
-var verboseDefault = debuglog("execa").enabled ? "full" : "none";
+var verboseDefault = (0, import_node_util.debuglog)("execa").enabled ? "full" : "none";
 var DEFAULT_OPTIONS = {
   lines: false,
   buffer: true,
@@ -882,18 +877,18 @@ var isVerboseFunction = (fdVerbose) => typeof fdVerbose === "function";
 var VERBOSE_VALUES = ["none", "short", "full"];
 
 // node_modules/execa/lib/verbose/log.js
-import { inspect } from "util";
+var import_node_util3 = require("util");
 
 // node_modules/execa/lib/arguments/escape.js
-import { platform } from "process";
-import { stripVTControlCharacters } from "util";
+var import_node_process2 = require("process");
+var import_node_util2 = require("util");
 var joinCommand = (filePath, rawArguments) => {
   const fileAndArguments = [filePath, ...rawArguments];
   const command = fileAndArguments.join(" ");
   const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
   return { command, escapedCommand };
 };
-var escapeLines = (lines) => stripVTControlCharacters(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
+var escapeLines = (lines) => (0, import_node_util2.stripVTControlCharacters)(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
 var escapeControlCharacters = (line) => line.replaceAll(SPECIAL_CHAR_REGEXP, (character) => escapeControlCharacter(character));
 var escapeControlCharacter = (character) => {
   const commonEscape = COMMON_ESCAPES[character];
@@ -925,16 +920,16 @@ var quoteString = (escapedArgument) => {
   if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
     return escapedArgument;
   }
-  return platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
+  return import_node_process2.platform === "win32" ? `"${escapedArgument.replaceAll('"', '""')}"` : `'${escapedArgument.replaceAll("'", "'\\''")}'`;
 };
 var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 
 // node_modules/is-unicode-supported/index.js
-import process3 from "process";
+var import_node_process3 = __toESM(require("process"), 1);
 function isUnicodeSupported() {
-  const { env } = process3;
+  const { env } = import_node_process3.default;
   const { TERM, TERM_PROGRAM } = env;
-  if (process3.platform !== "win32") {
+  if (import_node_process3.default.platform !== "win32") {
     return TERM !== "linux";
   }
   return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
@@ -1217,8 +1212,8 @@ var figures_default = figures;
 var replacements = Object.entries(specialMainSymbols);
 
 // node_modules/yoctocolors/base.js
-import tty from "tty";
-var hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
+var import_node_tty = __toESM(require("tty"), 1);
+var hasColors = import_node_tty.default?.WriteStream?.prototype?.hasColors?.() ?? false;
 var format = (open, close) => {
   if (!hasColors) {
     return (input) => input;
@@ -1370,7 +1365,7 @@ var getPrintedLine = (verboseObject) => {
   return { verboseLine, verboseObject };
 };
 var serializeVerboseMessage = (message) => {
-  const messageString = typeof message === "string" ? message : inspect(message);
+  const messageString = typeof message === "string" ? message : (0, import_node_util3.inspect)(message);
   const escapedMessage = escapeLines(messageString);
   return escapedMessage.replaceAll("	", " ".repeat(TAB_SIZE));
 };
@@ -1417,9 +1412,9 @@ var validateVerbose = (verbose) => {
 };
 
 // node_modules/execa/lib/return/duration.js
-import { hrtime } from "process";
-var getStartTime = () => hrtime.bigint();
-var getDurationMs = (startTime) => Number(hrtime.bigint() - startTime) / 1e6;
+var import_node_process4 = require("process");
+var getStartTime = () => import_node_process4.hrtime.bigint();
+var getDurationMs = (startTime) => Number(import_node_process4.hrtime.bigint() - startTime) / 1e6;
 
 // node_modules/execa/lib/arguments/command.js
 var handleCommand = (filePath, rawArguments, rawOptions) => {
@@ -1437,13 +1432,13 @@ var handleCommand = (filePath, rawArguments, rawOptions) => {
 };
 
 // node_modules/execa/lib/arguments/options.js
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_process8 = __toESM(require("process"), 1);
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import path6 from "path";
-import process6 from "process";
 
 // node_modules/npm-run-path/index.js
-import process4 from "process";
-import path3 from "path";
+var import_node_process5 = __toESM(require("process"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // node_modules/npm-run-path/node_modules/path-key/index.js
 function pathKey(options = {}) {
@@ -1458,23 +1453,23 @@ function pathKey(options = {}) {
 }
 
 // node_modules/unicorn-magic/node.js
-import { promisify } from "util";
-import { execFile as execFileCallback, execFileSync as execFileSyncOriginal } from "child_process";
-import path from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var execFileOriginal = promisify(execFileCallback);
+var import_node_util4 = require("util");
+var import_node_child_process2 = require("child_process");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var execFileOriginal = (0, import_node_util4.promisify)(import_node_child_process2.execFile);
 function toPath(urlOrPath) {
-  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+  return urlOrPath instanceof URL ? (0, import_node_url2.fileURLToPath)(urlOrPath) : urlOrPath;
 }
 function traversePathUp(startPath) {
   return {
     *[Symbol.iterator]() {
-      let currentPath = path.resolve(toPath(startPath));
+      let currentPath = import_node_path.default.resolve(toPath(startPath));
       let previousPath;
       while (previousPath !== currentPath) {
         yield currentPath;
         previousPath = currentPath;
-        currentPath = path.resolve(currentPath, "..");
+        currentPath = import_node_path.default.resolve(currentPath, "..");
       }
     }
   };
@@ -1483,38 +1478,38 @@ var TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
 
 // node_modules/npm-run-path/index.js
 var npmRunPath = ({
-  cwd = process4.cwd(),
-  path: pathOption = process4.env[pathKey()],
+  cwd = import_node_process5.default.cwd(),
+  path: pathOption = import_node_process5.default.env[pathKey()],
   preferLocal = true,
-  execPath: execPath2 = process4.execPath,
+  execPath: execPath2 = import_node_process5.default.execPath,
   addExecPath = true
 } = {}) => {
-  const cwdPath = path3.resolve(toPath(cwd));
+  const cwdPath = import_node_path2.default.resolve(toPath(cwd));
   const result = [];
-  const pathParts = pathOption.split(path3.delimiter);
+  const pathParts = pathOption.split(import_node_path2.default.delimiter);
   if (preferLocal) {
     applyPreferLocal(result, pathParts, cwdPath);
   }
   if (addExecPath) {
     applyExecPath(result, pathParts, execPath2, cwdPath);
   }
-  return pathOption === "" || pathOption === path3.delimiter ? `${result.join(path3.delimiter)}${pathOption}` : [...result, pathOption].join(path3.delimiter);
+  return pathOption === "" || pathOption === import_node_path2.default.delimiter ? `${result.join(import_node_path2.default.delimiter)}${pathOption}` : [...result, pathOption].join(import_node_path2.default.delimiter);
 };
 var applyPreferLocal = (result, pathParts, cwdPath) => {
   for (const directory of traversePathUp(cwdPath)) {
-    const pathPart = path3.join(directory, "node_modules/.bin");
+    const pathPart = import_node_path2.default.join(directory, "node_modules/.bin");
     if (!pathParts.includes(pathPart)) {
       result.push(pathPart);
     }
   }
 };
 var applyExecPath = (result, pathParts, execPath2, cwdPath) => {
-  const pathPart = path3.resolve(cwdPath, toPath(execPath2), "..");
+  const pathPart = import_node_path2.default.resolve(cwdPath, toPath(execPath2), "..");
   if (!pathParts.includes(pathPart)) {
     result.push(pathPart);
   }
 };
-var npmRunPathEnv = ({ env = process4.env, ...options } = {}) => {
+var npmRunPathEnv = ({ env = import_node_process5.default.env, ...options } = {}) => {
   env = { ...env };
   const pathName = pathKey({ env });
   options.path = env[pathName];
@@ -1523,7 +1518,7 @@ var npmRunPathEnv = ({ env = process4.env, ...options } = {}) => {
 };
 
 // node_modules/execa/lib/terminate/kill.js
-import { setTimeout as setTimeout2 } from "timers/promises";
+var import_promises2 = require("timers/promises");
 
 // node_modules/execa/lib/return/final-error.js
 var getFinalError = (originalError, message, isSync) => {
@@ -1558,10 +1553,10 @@ var ExecaSyncError = class extends Error {
 setErrorName(ExecaSyncError, ExecaSyncError.name);
 
 // node_modules/execa/lib/terminate/signal.js
-import { constants as constants3 } from "os";
+var import_node_os3 = require("os");
 
 // node_modules/human-signals/build/src/main.js
-import { constants as constants2 } from "os";
+var import_node_os2 = require("os");
 
 // node_modules/human-signals/build/src/realtime.js
 var getRealtimeSignals = () => {
@@ -1579,7 +1574,7 @@ var SIGRTMIN = 34;
 var SIGRTMAX = 64;
 
 // node_modules/human-signals/build/src/signals.js
-import { constants } from "os";
+var import_node_os = require("os");
 
 // node_modules/human-signals/build/src/core.js
 var SIGNALS = [
@@ -1870,7 +1865,7 @@ var normalizeSignal = ({
 }) => {
   const {
     signals: { [name]: constantSignal }
-  } = constants;
+  } = import_node_os.constants;
   const supported = constantSignal !== void 0;
   const number = supported ? constantSignal : defaultNumber;
   return { name, number, description, supported, action, forced, standard };
@@ -1919,7 +1914,7 @@ var getSignalByNumber = (number, signals2) => {
   };
 };
 var findSignalByNumber = (number, signals2) => {
-  const signal = signals2.find(({ name }) => constants2.signals[name] === number);
+  const signal = signals2.find(({ name }) => import_node_os2.constants.signals[name] === number);
   if (signal !== void 0) {
     return signal;
   }
@@ -1953,13 +1948,13 @@ var normalizeSignalInteger = (signalInteger, optionName) => {
   throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.
 ${getAvailableSignals()}`);
 };
-var getSignalsIntegerToName = () => new Map(Object.entries(constants3.signals).reverse().map(([signalName, signalInteger]) => [signalInteger, signalName]));
+var getSignalsIntegerToName = () => new Map(Object.entries(import_node_os3.constants.signals).reverse().map(([signalName, signalInteger]) => [signalInteger, signalName]));
 var signalsIntegerToName = getSignalsIntegerToName();
 var normalizeSignalName = (signalName, optionName) => {
-  if (signalName in constants3.signals) {
+  if (signalName in import_node_os3.constants.signals) {
     return signalName;
   }
-  if (signalName.toUpperCase() in constants3.signals) {
+  if (signalName.toUpperCase() in import_node_os3.constants.signals) {
     throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
   }
   throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.
@@ -1967,8 +1962,8 @@ ${getAvailableSignals()}`);
 };
 var getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
 Available signal numbers: ${getAvailableSignalIntegers()}.`;
-var getAvailableSignalNames = () => Object.keys(constants3.signals).sort().map((signalName) => `'${signalName}'`).join(", ");
-var getAvailableSignalIntegers = () => [...new Set(Object.values(constants3.signals).sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))].join(", ");
+var getAvailableSignalNames = () => Object.keys(import_node_os3.constants.signals).sort().map((signalName) => `'${signalName}'`).join(", ");
+var getAvailableSignalIntegers = () => [...new Set(Object.values(import_node_os3.constants.signals).sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))].join(", ");
 var getSignalDescription = (signal) => signalsByName[signal].description;
 
 // node_modules/execa/lib/terminate/kill.js
@@ -2030,7 +2025,7 @@ var killOnTimeout = async ({ kill, forceKillAfterDelay, context, controllerSigna
     return;
   }
   try {
-    await setTimeout2(forceKillAfterDelay, void 0, { signal: controllerSignal });
+    await (0, import_promises2.setTimeout)(forceKillAfterDelay, void 0, { signal: controllerSignal });
     if (kill("SIGKILL")) {
       context.isForcefullyTerminated ??= true;
     }
@@ -2039,10 +2034,10 @@ var killOnTimeout = async ({ kill, forceKillAfterDelay, context, controllerSigna
 };
 
 // node_modules/execa/lib/utils/abort-signal.js
-import { once } from "events";
+var import_node_events = require("events");
 var onAbortedSignal = async (mainSignal, stopSignal) => {
   if (!mainSignal.aborted) {
-    await once(mainSignal, "abort", { signal: stopSignal });
+    await (0, import_node_events.once)(mainSignal, "abort", { signal: stopSignal });
   }
 };
 
@@ -2061,10 +2056,10 @@ var terminateOnCancel = async (subprocess, cancelSignal, context, { signal }) =>
 };
 
 // node_modules/execa/lib/ipc/graceful.js
-import { scheduler as scheduler2 } from "timers/promises";
+var import_promises4 = require("timers/promises");
 
 // node_modules/execa/lib/ipc/send.js
-import { promisify as promisify2 } from "util";
+var import_node_util5 = require("util");
 
 // node_modules/execa/lib/ipc/validation.js
 var validateIpcMethod = ({ methodName, isSubprocess, ipc, isConnected: isConnected2 }) => {
@@ -2228,27 +2223,27 @@ var serializeOptionValue = (value) => {
 };
 
 // node_modules/execa/lib/ipc/strict.js
-import { once as once3 } from "events";
+var import_node_events5 = require("events");
 
 // node_modules/execa/lib/utils/max-listeners.js
-import { addAbortListener } from "events";
+var import_node_events2 = require("events");
 var incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
   const maxListeners = eventEmitter.getMaxListeners();
   if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
     return;
   }
   eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-  addAbortListener(signal, () => {
+  (0, import_node_events2.addAbortListener)(signal, () => {
     eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
   });
 };
 
 // node_modules/execa/lib/ipc/forward.js
-import { EventEmitter } from "events";
+var import_node_events4 = require("events");
 
 // node_modules/execa/lib/ipc/incoming.js
-import { once as once2 } from "events";
-import { scheduler } from "timers/promises";
+var import_node_events3 = require("events");
+var import_promises3 = require("timers/promises");
 
 // node_modules/execa/lib/ipc/reference.js
 var addReference = (channel, reference) => {
@@ -2295,7 +2290,7 @@ var onMessage = async ({ anyProcess, channel, isSubprocess, ipcEmitter }, wrappe
   }
   while (incomingMessages.length > 0) {
     await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
-    await scheduler.yield();
+    await import_promises3.scheduler.yield();
     const message = await handleStrictRequest({
       wrappedMessage: incomingMessages[0],
       anyProcess,
@@ -2312,7 +2307,7 @@ var onDisconnect = async ({ anyProcess, channel, isSubprocess, ipcEmitter, bound
   abortOnDisconnect();
   const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
   while (incomingMessages?.length > 0) {
-    await once2(ipcEmitter, "message:done");
+    await (0, import_node_events3.once)(ipcEmitter, "message:done");
   }
   anyProcess.removeListener("message", boundOnMessage);
   redoAddedReferences(channel, isSubprocess);
@@ -2326,7 +2321,7 @@ var getIpcEmitter = (anyProcess, channel, isSubprocess) => {
   if (IPC_EMITTERS.has(anyProcess)) {
     return IPC_EMITTERS.get(anyProcess);
   }
-  const ipcEmitter = new EventEmitter();
+  const ipcEmitter = new import_node_events4.EventEmitter();
   ipcEmitter.connected = true;
   IPC_EMITTERS.set(anyProcess, ipcEmitter);
   forwardEvents({
@@ -2437,7 +2432,7 @@ var waitForStrictResponse = async (wrappedMessage, anyProcess, isSubprocess) =>
 var STRICT_RESPONSES = {};
 var throwOnDisconnect = async (anyProcess, isSubprocess, { signal }) => {
   incrementMaxListeners(anyProcess, 1, signal);
-  await once3(anyProcess, "disconnect", { signal });
+  await (0, import_node_events5.once)(anyProcess, "disconnect", { signal });
   throwOnStrictDisconnect(isSubprocess);
 };
 var REQUEST_TYPE = "execa:ipc:request";
@@ -2534,7 +2529,7 @@ var getSendMethod = (anyProcess) => {
   if (PROCESS_SEND_METHODS.has(anyProcess)) {
     return PROCESS_SEND_METHODS.get(anyProcess);
   }
-  const sendMethod = promisify2(anyProcess.send.bind(anyProcess));
+  const sendMethod = (0, import_node_util5.promisify)(anyProcess.send.bind(anyProcess));
   PROCESS_SEND_METHODS.set(anyProcess, sendMethod);
   return sendMethod;
 };
@@ -2575,7 +2570,7 @@ var startIpc = async ({ anyProcess, channel, isSubprocess, ipc }) => {
     return;
   }
   getIpcEmitter(anyProcess, channel, isSubprocess);
-  await scheduler2.yield();
+  await import_promises4.scheduler.yield();
 };
 var cancelListening = false;
 var handleAbort = (wrappedMessage) => {
@@ -2648,7 +2643,7 @@ var getReason = ({ reason }) => {
 };
 
 // node_modules/execa/lib/terminate/timeout.js
-import { setTimeout as setTimeout3 } from "timers/promises";
+var import_promises5 = require("timers/promises");
 var validateTimeout = ({ timeout }) => {
   if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
     throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
@@ -2656,15 +2651,15 @@ var validateTimeout = ({ timeout }) => {
 };
 var throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === void 0 ? [] : [killAfterTimeout(subprocess, timeout, context, controller)];
 var killAfterTimeout = async (subprocess, timeout, context, { signal }) => {
-  await setTimeout3(timeout, void 0, { signal });
+  await (0, import_promises5.setTimeout)(timeout, void 0, { signal });
   context.terminationReason ??= "timeout";
   subprocess.kill();
   throw new DiscardedError();
 };
 
 // node_modules/execa/lib/methods/node.js
-import { execPath, execArgv } from "process";
-import path4 from "path";
+var import_node_process6 = require("process");
+var import_node_path3 = __toESM(require("path"), 1);
 var mapNode = ({ options }) => {
   if (options.node === false) {
     throw new TypeError('The "node" option cannot be false with `execaNode()`.');
@@ -2673,8 +2668,8 @@ var mapNode = ({ options }) => {
 };
 var handleNodeOption = (file, commandArguments, {
   node: shouldHandleNode = false,
-  nodePath = execPath,
-  nodeOptions = execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
+  nodePath = import_node_process6.execPath,
+  nodeOptions = import_node_process6.execArgv.filter((nodeOption) => !nodeOption.startsWith("--inspect")),
   cwd,
   execPath: formerNodePath,
   ...options
@@ -2683,7 +2678,7 @@ var handleNodeOption = (file, commandArguments, {
     throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
   }
   const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
-  const resolvedNodePath = path4.resolve(cwd, normalizedNodePath);
+  const resolvedNodePath = import_node_path3.default.resolve(cwd, normalizedNodePath);
   const newOptions = {
     ...options,
     nodePath: resolvedNodePath,
@@ -2693,7 +2688,7 @@ var handleNodeOption = (file, commandArguments, {
   if (!shouldHandleNode) {
     return [file, commandArguments, newOptions];
   }
-  if (path4.basename(file, ".exe") === "node") {
+  if (import_node_path3.default.basename(file, ".exe") === "node") {
     throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
   }
   return [
@@ -2704,7 +2699,7 @@ var handleNodeOption = (file, commandArguments, {
 };
 
 // node_modules/execa/lib/ipc/ipc-input.js
-import { serialize } from "v8";
+var import_node_v8 = require("v8");
 var validateIpcInputOption = ({ ipcInput, ipc, serialization }) => {
   if (ipcInput === void 0) {
     return;
@@ -2716,7 +2711,7 @@ var validateIpcInputOption = ({ ipcInput, ipc, serialization }) => {
 };
 var validateAdvancedInput = (ipcInput) => {
   try {
-    serialize(ipcInput);
+    (0, import_node_v8.serialize)(ipcInput);
   } catch (error) {
     throw new Error("The `ipcInput` option is not serializable with a structured clone.", { cause: error });
   }
@@ -2782,16 +2777,16 @@ var ENCODING_ALIASES = {
 var serializeEncoding = (encoding) => typeof encoding === "string" ? `"${encoding}"` : String(encoding);
 
 // node_modules/execa/lib/arguments/cwd.js
-import { statSync } from "fs";
-import path5 from "path";
-import process5 from "process";
+var import_node_fs = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_process7 = __toESM(require("process"), 1);
 var normalizeCwd = (cwd = getDefaultCwd()) => {
   const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
-  return path5.resolve(cwdString);
+  return import_node_path4.default.resolve(cwdString);
 };
 var getDefaultCwd = () => {
   try {
-    return process5.cwd();
+    return import_node_process7.default.cwd();
   } catch (error) {
     error.message = `The current directory does not exist.
 ${error.message}`;
@@ -2804,7 +2799,7 @@ var fixCwdError = (originalMessage, cwd) => {
   }
   let cwdStat;
   try {
-    cwdStat = statSync(cwd);
+    cwdStat = (0, import_node_fs.statSync)(cwd);
   } catch (error) {
     return `The "cwd" option is invalid: ${cwd}.
 ${error.message}
@@ -2834,7 +2829,7 @@ var normalizeOptions = (filePath, rawArguments, rawOptions) => {
   options.killSignal = normalizeKillSignal(options.killSignal);
   options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
   options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
-  if (process6.platform === "win32" && path6.basename(file, ".exe") === "cmd") {
+  if (import_node_process8.default.platform === "win32" && import_node_path5.default.basename(file, ".exe") === "cmd") {
     commandArguments.unshift("/q");
   }
   return { file, commandArguments, options };
@@ -2875,7 +2870,7 @@ var addDefaultOptions = ({
   serialization
 });
 var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
-  const env = extendEnv ? { ...process6.env, ...envOption } : envOption;
+  const env = extendEnv ? { ...import_node_process8.default.env, ...envOption } : envOption;
   if (preferLocal || node) {
     return npmRunPathEnv({
       env,
@@ -2892,7 +2887,7 @@ var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, no
 var concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0 ? [[file, ...commandArguments].join(" "), [], options] : [file, commandArguments, options];
 
 // node_modules/execa/lib/return/message.js
-import { inspect as inspect2 } from "util";
+var import_node_util6 = require("util");
 
 // node_modules/strip-final-newline/index.js
 function stripFinalNewline(input) {
@@ -2912,8 +2907,8 @@ var CR = "\r";
 var CR_BINARY = CR.codePointAt(0);
 
 // node_modules/get-stream/source/index.js
-import { on } from "events";
-import { finished } from "stream/promises";
+var import_node_events6 = require("events");
+var import_promises6 = require("stream/promises");
 
 // node_modules/is-stream/index.js
 function isStream(stream, { checkOpen = true } = {}) {
@@ -3279,7 +3274,7 @@ var stringMethods = {
 };
 
 // node_modules/get-stream/source/index.js
-Object.assign(nodeImports, { on, finished });
+Object.assign(nodeImports, { on: import_node_events6.on, finished: import_promises6.finished });
 
 // node_modules/execa/lib/io/max-buffer.js
 var handleMaxBuffer = ({ error, stream, readableObjectMode, lines, encoding, fdNumber }) => {
@@ -3446,7 +3441,7 @@ var getOriginalMessage = (originalError, cwd) => {
   const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
   return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
-var serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : inspect2(ipcMessage);
+var serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, import_node_util6.inspect)(ipcMessage);
 var serializeMessagePart = (messagePart) => Array.isArray(messagePart) ? messagePart.map((messageItem) => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join("\n") : serializeMessageItem(messagePart);
 var serializeMessageItem = (messageItem) => {
   if (typeof messageItem === "string") {
@@ -3809,7 +3804,7 @@ var handleResult = (result, verboseInfo, { reject }) => {
 };
 
 // node_modules/execa/lib/stdio/handle-sync.js
-import { readFileSync as readFileSync2 } from "fs";
+var import_node_fs3 = require("fs");
 
 // node_modules/execa/lib/stdio/type.js
 var getStdioItemType = (value, optionName) => {
@@ -4052,7 +4047,7 @@ var normalizeGenerator = ({ stdioItem, stdioItem: { value }, index, newTransform
 var sortTransforms = (newTransforms, direction) => direction === "input" ? newTransforms.reverse() : newTransforms;
 
 // node_modules/execa/lib/stdio/direction.js
-import process7 from "process";
+var import_node_process9 = __toESM(require("process"), 1);
 var getStreamDirection = (stdioItems, fdNumber, optionName) => {
   const directions = stdioItems.map((stdioItem) => getStdioItemDirection(stdioItem, fdNumber));
   if (directions.includes("input") && directions.includes("output")) {
@@ -4092,10 +4087,10 @@ var guessStreamDirection = {
   }
 };
 var getStandardStreamDirection = (value) => {
-  if ([0, process7.stdin].includes(value)) {
+  if ([0, import_node_process9.default.stdin].includes(value)) {
     return "input";
   }
-  if ([1, 2, process7.stdout, process7.stderr].includes(value)) {
+  if ([1, 2, import_node_process9.default.stdout, import_node_process9.default.stderr].includes(value)) {
     return "output";
   }
 };
@@ -4139,8 +4134,8 @@ var normalizeStdioSync = (stdioArray, buffer, verboseInfo) => stdioArray.map((st
 var isOutputPipeOnly = (stdioOption) => stdioOption === "pipe" || Array.isArray(stdioOption) && stdioOption.every((item) => item === "pipe");
 
 // node_modules/execa/lib/stdio/native.js
-import { readFileSync } from "fs";
-import tty2 from "tty";
+var import_node_fs2 = require("fs");
+var import_node_tty2 = __toESM(require("tty"), 1);
 var handleNativeStream = ({ stdioItem, stdioItem: { type }, isStdioArray, fdNumber, direction, isSync }) => {
   if (!isStdioArray || type !== "native") {
     return stdioItem;
@@ -4170,10 +4165,10 @@ var getTargetFd = ({ value, optionName, fdNumber, direction }) => {
   if (direction === "output") {
     return { type: "fileNumber", value: targetFdNumber, optionName };
   }
-  if (tty2.isatty(targetFdNumber)) {
+  if (import_node_tty2.default.isatty(targetFdNumber)) {
     throw new TypeError(`The \`${optionName}: ${serializeOptionValue(value)}\` option is invalid: it cannot be a TTY with synchronous methods.`);
   }
-  return { type: "uint8Array", value: bufferToUint8Array(readFileSync(targetFdNumber)), optionName };
+  return { type: "uint8Array", value: bufferToUint8Array((0, import_node_fs2.readFileSync)(targetFdNumber)), optionName };
 };
 var getTargetFdNumber = (value, fdNumber) => {
   if (value === "inherit") {
@@ -4506,8 +4501,8 @@ var addProperties = {
 var addPropertiesSync = {
   input: {
     ...addProperties,
-    fileUrl: ({ value }) => ({ contents: [bufferToUint8Array(readFileSync2(value))] }),
-    filePath: ({ value: { file } }) => ({ contents: [bufferToUint8Array(readFileSync2(file))] }),
+    fileUrl: ({ value }) => ({ contents: [bufferToUint8Array((0, import_node_fs3.readFileSync)(value))] }),
+    filePath: ({ value: { file } }) => ({ contents: [bufferToUint8Array((0, import_node_fs3.readFileSync)(file))] }),
     fileNumber: forbiddenIfSync,
     iterable: ({ value }) => ({ contents: [...value] }),
     string: ({ value }) => ({ contents: [value] }),
@@ -4529,7 +4524,7 @@ var stripNewline = (value, { stripFinalNewline: stripFinalNewline2 }, fdNumber)
 var getStripFinalNewline = (stripFinalNewline2, fdNumber) => fdNumber === "all" ? stripFinalNewline2[1] || stripFinalNewline2[2] : stripFinalNewline2[fdNumber];
 
 // node_modules/execa/lib/transform/generator.js
-import { Transform, getDefaultHighWaterMark } from "stream";
+var import_node_stream = require("stream");
 
 // node_modules/execa/lib/transform/split.js
 var getSplitLinesGenerator = (binary, preserveNewlines, skipped, state) => binary || skipped ? void 0 : initializeSplitLines(preserveNewlines, state);
@@ -4612,10 +4607,10 @@ var linesUint8ArrayInfo = {
 };
 
 // node_modules/execa/lib/transform/validate.js
-import { Buffer as Buffer2 } from "buffer";
+var import_node_buffer = require("buffer");
 var getValidateTransformInput = (writableObjectMode, optionName) => writableObjectMode ? void 0 : validateStringTransformInput.bind(void 0, optionName);
 var validateStringTransformInput = function* (optionName, chunk) {
-  if (typeof chunk !== "string" && !isUint8Array(chunk) && !Buffer2.isBuffer(chunk)) {
+  if (typeof chunk !== "string" && !isUint8Array(chunk) && !import_node_buffer.Buffer.isBuffer(chunk)) {
     throw new TypeError(`The \`${optionName}\` option's transform must use "objectMode: true" to receive as input: ${typeof chunk}.`);
   }
   yield chunk;
@@ -4641,8 +4636,8 @@ Instead, \`yield\` should either be called with a value, or not be called at all
 };
 
 // node_modules/execa/lib/transform/encoding-transform.js
-import { Buffer as Buffer3 } from "buffer";
-import { StringDecoder as StringDecoder2 } from "string_decoder";
+var import_node_buffer2 = require("buffer");
+var import_node_string_decoder2 = require("string_decoder");
 var getEncodingTransformGenerator = (binary, encoding, skipped) => {
   if (skipped) {
     return;
@@ -4650,14 +4645,14 @@ var getEncodingTransformGenerator = (binary, encoding, skipped) => {
   if (binary) {
     return { transform: encodingUint8ArrayGenerator.bind(void 0, new TextEncoder()) };
   }
-  const stringDecoder = new StringDecoder2(encoding);
+  const stringDecoder = new import_node_string_decoder2.StringDecoder(encoding);
   return {
     transform: encodingStringGenerator.bind(void 0, stringDecoder),
     final: encodingStringFinal.bind(void 0, stringDecoder)
   };
 };
 var encodingUint8ArrayGenerator = function* (textEncoder3, chunk) {
-  if (Buffer3.isBuffer(chunk)) {
+  if (import_node_buffer2.Buffer.isBuffer(chunk)) {
     yield bufferToUint8Array(chunk);
   } else if (typeof chunk === "string") {
     yield textEncoder3.encode(chunk);
@@ -4676,8 +4671,8 @@ var encodingStringFinal = function* (stringDecoder) {
 };
 
 // node_modules/execa/lib/transform/run-async.js
-import { callbackify } from "util";
-var pushChunks = callbackify(async (getChunks, state, getChunksArguments, transformStream) => {
+var import_node_util7 = require("util");
+var pushChunks = (0, import_node_util7.callbackify)(async (getChunks, state, getChunksArguments, transformStream) => {
   state.currentIterable = getChunks(...getChunksArguments);
   try {
     for await (const chunk of state.currentIterable) {
@@ -4710,7 +4705,7 @@ var generatorFinalChunks = async function* (final, index, generators) {
     yield* transformChunk(finalChunk, generators, index + 1);
   }
 };
-var destroyTransform = callbackify(async ({ currentIterable }, error) => {
+var destroyTransform = (0, import_node_util7.callbackify)(async ({ currentIterable }, error) => {
   if (currentIterable !== void 0) {
     await (error ? currentIterable.throw(error) : currentIterable.return());
     return;
@@ -4778,11 +4773,11 @@ var generatorToStream = ({
   const transformMethod = transformAsync ? pushChunks.bind(void 0, transformChunk, state) : pushChunksSync.bind(void 0, transformChunkSync);
   const finalMethod = transformAsync || finalAsync ? pushChunks.bind(void 0, finalChunks, state) : pushChunksSync.bind(void 0, finalChunksSync);
   const destroyMethod = transformAsync || finalAsync ? destroyTransform.bind(void 0, state) : void 0;
-  const stream = new Transform({
+  const stream = new import_node_stream.Transform({
     writableObjectMode,
-    writableHighWaterMark: getDefaultHighWaterMark(writableObjectMode),
+    writableHighWaterMark: (0, import_node_stream.getDefaultHighWaterMark)(writableObjectMode),
     readableObjectMode,
-    readableHighWaterMark: getDefaultHighWaterMark(readableObjectMode),
+    readableHighWaterMark: (0, import_node_stream.getDefaultHighWaterMark)(readableObjectMode),
     transform(chunk, encoding2, done) {
       transformMethod([chunk, generators, 0], this, done);
     },
@@ -4853,7 +4848,7 @@ var validateSerializable = (newContents) => {
 };
 
 // node_modules/execa/lib/io/output-sync.js
-import { writeFileSync, appendFileSync } from "fs";
+var import_node_fs4 = require("fs");
 
 // node_modules/execa/lib/verbose/output.js
 var shouldLogOutput = ({ stdioItems, encoding, verboseInfo, fdNumber }) => fdNumber !== "all" && isFullVerbose(verboseInfo, fdNumber) && !BINARY_ENCODINGS.has(encoding) && fdUsesVerbose(fdNumber) && (stdioItems.some(({ type, value }) => type === "native" && PIPED_STDIO_VALUES.has(value)) || stdioItems.every(({ type }) => TRANSFORM_TYPES.has(type)));
@@ -4977,10 +4972,10 @@ var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
   for (const { path: path12, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
     const pathString = typeof path12 === "string" ? path12 : path12.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync(path12, serializedResult);
+      (0, import_node_fs4.appendFileSync)(path12, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync(path12, serializedResult);
+      (0, import_node_fs4.writeFileSync)(path12, serializedResult);
     }
   }
 };
@@ -5009,7 +5004,7 @@ var getAllSync = ([, stdout, stderr], options) => {
 };
 
 // node_modules/execa/lib/resolve/exit-async.js
-import { once as once4 } from "events";
+var import_node_events7 = require("events");
 var waitForExit = async (subprocess, context) => {
   const [exitCode, signal] = await waitForExitOrError(subprocess);
   context.isForcefullyTerminated ??= false;
@@ -5017,8 +5012,8 @@ var waitForExit = async (subprocess, context) => {
 };
 var waitForExitOrError = async (subprocess) => {
   const [spawnPayload, exitPayload] = await Promise.allSettled([
-    once4(subprocess, "spawn"),
-    once4(subprocess, "exit")
+    (0, import_node_events7.once)(subprocess, "spawn"),
+    (0, import_node_events7.once)(subprocess, "exit")
   ]);
   if (spawnPayload.status === "rejected") {
     return [];
@@ -5027,7 +5022,7 @@ var waitForExitOrError = async (subprocess) => {
 };
 var waitForSubprocessExit = async (subprocess) => {
   try {
-    return await once4(subprocess, "exit");
+    return await (0, import_node_events7.once)(subprocess, "exit");
   } catch {
     return waitForSubprocessExit(subprocess);
   }
@@ -5153,7 +5148,7 @@ var runSubprocessSync = ({ file, commandArguments, options, command, escapedComm
   try {
     addInputOptionsSync(fileDescriptors, options);
     const normalizedOptions = normalizeSpawnSyncOptions(options);
-    return spawnSync(...concatenateShell(file, commandArguments, normalizedOptions));
+    return (0, import_node_child_process3.spawnSync)(...concatenateShell(file, commandArguments, normalizedOptions));
   } catch (error) {
     return makeEarlyError({
       error,
@@ -5195,14 +5190,14 @@ var getSyncResult = ({ error, exitCode, signal, timedOut, isMaxBuffer, stdio, al
 });
 
 // node_modules/execa/lib/methods/main-async.js
-import { setMaxListeners } from "events";
-import { spawn } from "child_process";
+var import_node_events14 = require("events");
+var import_node_child_process5 = require("child_process");
 
 // node_modules/execa/lib/ipc/methods.js
-import process8 from "process";
+var import_node_process10 = __toESM(require("process"), 1);
 
 // node_modules/execa/lib/ipc/get-one.js
-import { once as once5, on as on2 } from "events";
+var import_node_events8 = require("events");
 var getOneMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true, filter } = {}) => {
   validateIpcMethod({
     methodName: "getOneMessage",
@@ -5238,26 +5233,26 @@ var getOneMessageAsync = async ({ anyProcess, channel, isSubprocess, filter, ref
 };
 var getMessage = async (ipcEmitter, filter, { signal }) => {
   if (filter === void 0) {
-    const [message] = await once5(ipcEmitter, "message", { signal });
+    const [message] = await (0, import_node_events8.once)(ipcEmitter, "message", { signal });
     return message;
   }
-  for await (const [message] of on2(ipcEmitter, "message", { signal })) {
+  for await (const [message] of (0, import_node_events8.on)(ipcEmitter, "message", { signal })) {
     if (filter(message)) {
       return message;
     }
   }
 };
 var throwOnDisconnect2 = async (ipcEmitter, isSubprocess, { signal }) => {
-  await once5(ipcEmitter, "disconnect", { signal });
+  await (0, import_node_events8.once)(ipcEmitter, "disconnect", { signal });
   throwOnEarlyDisconnect(isSubprocess);
 };
 var throwOnStrictError = async (ipcEmitter, isSubprocess, { signal }) => {
-  const [error] = await once5(ipcEmitter, "strict:error", { signal });
+  const [error] = await (0, import_node_events8.once)(ipcEmitter, "strict:error", { signal });
   throw getStrictResponseError(error, isSubprocess);
 };
 
 // node_modules/execa/lib/ipc/get-each.js
-import { once as once6, on as on3 } from "events";
+var import_node_events9 = require("events");
 var getEachMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true } = {}) => loopOnMessages({
   anyProcess,
   channel,
@@ -5297,14 +5292,14 @@ var loopOnMessages = ({ anyProcess, channel, isSubprocess, ipc, shouldAwait, ref
 };
 var stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
   try {
-    await once6(ipcEmitter, "disconnect", { signal: controller.signal });
+    await (0, import_node_events9.once)(ipcEmitter, "disconnect", { signal: controller.signal });
     controller.abort();
   } catch {
   }
 };
 var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state }) => {
   try {
-    const [error] = await once6(ipcEmitter, "strict:error", { signal: controller.signal });
+    const [error] = await (0, import_node_events9.once)(ipcEmitter, "strict:error", { signal: controller.signal });
     state.error = getStrictResponseError(error, isSubprocess);
     controller.abort();
   } catch {
@@ -5312,7 +5307,7 @@ var abortOnStrictError = async ({ ipcEmitter, isSubprocess, controller, state })
 };
 var iterateOnMessages = async function* ({ anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference }) {
   try {
-    for await (const [message] of on3(ipcEmitter, "message", { signal: controller.signal })) {
+    for await (const [message] of (0, import_node_events9.on)(ipcEmitter, "message", { signal: controller.signal })) {
       throwIfStrictError(state);
       yield message;
     }
@@ -5340,9 +5335,9 @@ var addIpcMethods = (subprocess, { ipc }) => {
   Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
 };
 var getIpcExport = () => {
-  const anyProcess = process8;
+  const anyProcess = import_node_process10.default;
   const isSubprocess = true;
-  const ipc = process8.channel !== void 0;
+  const ipc = import_node_process10.default.channel !== void 0;
   return {
     ...getIpcMethods(anyProcess, isSubprocess, ipc),
     getCancelSignal: getCancelSignal.bind(void 0, {
@@ -5375,16 +5370,11 @@ var getIpcMethods = (anyProcess, isSubprocess, ipc) => ({
 });
 
 // node_modules/execa/lib/return/early-error.js
-import { ChildProcess as ChildProcess2 } from "child_process";
-import {
-  PassThrough,
-  Readable,
-  Writable,
-  Duplex
-} from "stream";
+var import_node_child_process4 = require("child_process");
+var import_node_stream2 = require("stream");
 var handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, options, startTime, verboseInfo }) => {
   cleanupCustomStreams(fileDescriptors);
-  const subprocess = new ChildProcess2();
+  const subprocess = new import_node_child_process4.ChildProcess();
   createDummyStreams(subprocess, fileDescriptors);
   Object.assign(subprocess, { readable, writable, duplex });
   const earlyError = makeEarlyError({
@@ -5415,23 +5405,23 @@ var createDummyStreams = (subprocess, fileDescriptors) => {
   });
 };
 var createDummyStream = () => {
-  const stream = new PassThrough();
+  const stream = new import_node_stream2.PassThrough();
   stream.end();
   return stream;
 };
-var readable = () => new Readable({ read() {
+var readable = () => new import_node_stream2.Readable({ read() {
 } });
-var writable = () => new Writable({ write() {
+var writable = () => new import_node_stream2.Writable({ write() {
 } });
-var duplex = () => new Duplex({ read() {
+var duplex = () => new import_node_stream2.Duplex({ read() {
 }, write() {
 } });
 var handleDummyPromise = async (error, verboseInfo, options) => handleResult(error, verboseInfo, options);
 
 // node_modules/execa/lib/stdio/handle-async.js
-import { createReadStream, createWriteStream } from "fs";
-import { Buffer as Buffer4 } from "buffer";
-import { Readable as Readable2, Writable as Writable2, Duplex as Duplex2 } from "stream";
+var import_node_fs5 = require("fs");
+var import_node_buffer3 = require("buffer");
+var import_node_stream3 = require("stream");
 var handleStdioAsync = (options, verboseInfo) => handleStdio(addPropertiesAsync, options, verboseInfo, false);
 var forbiddenIfAsync = ({ type, optionName }) => {
   throw new TypeError(`The \`${optionName}\` option cannot be ${TYPE_TO_MESSAGE[type]}.`);
@@ -5443,7 +5433,7 @@ var addProperties2 = {
   nodeStream: ({ value }) => ({ stream: value }),
   webTransform({ value: { transform, writableObjectMode, readableObjectMode } }) {
     const objectMode = writableObjectMode || readableObjectMode;
-    const stream = Duplex2.fromWeb(transform, { objectMode });
+    const stream = import_node_stream3.Duplex.fromWeb(transform, { objectMode });
     return { stream };
   },
   duplex: ({ value: { transform } }) => ({ stream: transform }),
@@ -5453,19 +5443,19 @@ var addProperties2 = {
 var addPropertiesAsync = {
   input: {
     ...addProperties2,
-    fileUrl: ({ value }) => ({ stream: createReadStream(value) }),
-    filePath: ({ value: { file } }) => ({ stream: createReadStream(file) }),
-    webStream: ({ value }) => ({ stream: Readable2.fromWeb(value) }),
-    iterable: ({ value }) => ({ stream: Readable2.from(value) }),
-    asyncIterable: ({ value }) => ({ stream: Readable2.from(value) }),
-    string: ({ value }) => ({ stream: Readable2.from(value) }),
-    uint8Array: ({ value }) => ({ stream: Readable2.from(Buffer4.from(value)) })
+    fileUrl: ({ value }) => ({ stream: (0, import_node_fs5.createReadStream)(value) }),
+    filePath: ({ value: { file } }) => ({ stream: (0, import_node_fs5.createReadStream)(file) }),
+    webStream: ({ value }) => ({ stream: import_node_stream3.Readable.fromWeb(value) }),
+    iterable: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+    asyncIterable: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+    string: ({ value }) => ({ stream: import_node_stream3.Readable.from(value) }),
+    uint8Array: ({ value }) => ({ stream: import_node_stream3.Readable.from(import_node_buffer3.Buffer.from(value)) })
   },
   output: {
     ...addProperties2,
-    fileUrl: ({ value }) => ({ stream: createWriteStream(value) }),
-    filePath: ({ value: { file, append } }) => ({ stream: createWriteStream(file, append ? { flags: "a" } : {}) }),
-    webStream: ({ value }) => ({ stream: Writable2.fromWeb(value) }),
+    fileUrl: ({ value }) => ({ stream: (0, import_node_fs5.createWriteStream)(value) }),
+    filePath: ({ value: { file, append } }) => ({ stream: (0, import_node_fs5.createWriteStream)(file, append ? { flags: "a" } : {}) }),
+    webStream: ({ value }) => ({ stream: import_node_stream3.Writable.fromWeb(value) }),
     iterable: forbiddenIfAsync,
     asyncIterable: forbiddenIfAsync,
     string: forbiddenIfAsync,
@@ -5474,9 +5464,9 @@ var addPropertiesAsync = {
 };
 
 // node_modules/@sindresorhus/merge-streams/index.js
-import { on as on4, once as once7 } from "events";
-import { PassThrough as PassThroughStream, getDefaultHighWaterMark as getDefaultHighWaterMark2 } from "stream";
-import { finished as finished2 } from "stream/promises";
+var import_node_events10 = require("events");
+var import_node_stream4 = require("stream");
+var import_promises7 = require("stream/promises");
 function mergeStreams(streams) {
   if (!Array.isArray(streams)) {
     throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
@@ -5498,12 +5488,12 @@ function mergeStreams(streams) {
 }
 var getHighWaterMark = (streams, objectMode) => {
   if (streams.length === 0) {
-    return getDefaultHighWaterMark2(objectMode);
+    return (0, import_node_stream4.getDefaultHighWaterMark)(objectMode);
   }
   const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
   return Math.max(...highWaterMarks);
 };
-var MergedStream = class extends PassThroughStream {
+var MergedStream = class extends import_node_stream4.PassThrough {
   #streams = /* @__PURE__ */ new Set([]);
   #ended = /* @__PURE__ */ new Set([]);
   #aborted = /* @__PURE__ */ new Set([]);
@@ -5559,14 +5549,14 @@ var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) =>
 };
 var onMergedStreamEnd = async (passThroughStream, { signal }) => {
   try {
-    await finished2(passThroughStream, { signal, cleanup: true });
+    await (0, import_promises7.finished)(passThroughStream, { signal, cleanup: true });
   } catch (error) {
     errorOrAbortStream(passThroughStream, error);
     throw error;
   }
 };
 var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
-  for await (const [unpipedStream] of on4(passThroughStream, "unpipe", { signal })) {
+  for await (const [unpipedStream] of (0, import_node_events10.on)(passThroughStream, "unpipe", { signal })) {
     if (streams.has(unpipedStream)) {
       unpipedStream.emit(unpipeEvent);
     }
@@ -5626,7 +5616,7 @@ var afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
 };
 var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted: aborted2, controller: { signal } }) => {
   try {
-    await finished2(stream, {
+    await (0, import_promises7.finished)(stream, {
       signal,
       cleanup: true,
       readable: true,
@@ -5647,9 +5637,9 @@ var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, abort
   }
 };
 var onInputStreamUnpipe = async ({ stream, streams, ended, aborted: aborted2, unpipeEvent, controller: { signal } }) => {
-  await once7(stream, unpipeEvent, { signal });
+  await (0, import_node_events10.once)(stream, unpipeEvent, { signal });
   if (!stream.readable) {
-    return once7(signal, "abort", { signal });
+    return (0, import_node_events10.once)(signal, "abort", { signal });
   }
   streams.delete(stream);
   ended.delete(stream);
@@ -5691,7 +5681,7 @@ var PASSTHROUGH_LISTENERS_COUNT = 2;
 var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
 // node_modules/execa/lib/io/pipeline.js
-import { finished as finished3 } from "stream/promises";
+var import_promises8 = require("stream/promises");
 var pipeStreams = (source, destination) => {
   source.pipe(destination);
   onSourceFinish(source, destination);
@@ -5702,7 +5692,7 @@ var onSourceFinish = async (source, destination) => {
     return;
   }
   try {
-    await finished3(source, { cleanup: true, readable: true, writable: false });
+    await (0, import_promises8.finished)(source, { cleanup: true, readable: true, writable: false });
   } catch {
   }
   endDestinationStream(destination);
@@ -5717,7 +5707,7 @@ var onDestinationFinish = async (source, destination) => {
     return;
   }
   try {
-    await finished3(destination, { cleanup: true, readable: false, writable: true });
+    await (0, import_promises8.finished)(destination, { cleanup: true, readable: false, writable: true });
   } catch {
   }
   abortSourceStream(source);
@@ -5781,7 +5771,7 @@ var setStandardStreamMaxListeners = (stream, { signal }) => {
 var MAX_LISTENERS_INCREMENT = 2;
 
 // node_modules/execa/lib/terminate/cleanup.js
-import { addAbortListener as addAbortListener2 } from "events";
+var import_node_events11 = require("events");
 
 // node_modules/signal-exit/dist/mjs/signals.js
 var signals = [];
@@ -6042,7 +6032,7 @@ var cleanupOnExit = (subprocess, { cleanup, detached }, { signal }) => {
   const removeExitHandler = onExit(() => {
     subprocess.kill();
   });
-  addAbortListener2(signal, () => {
+  (0, import_node_events11.addAbortListener)(signal, () => {
     removeExitHandler();
   });
 };
@@ -6188,7 +6178,7 @@ var waitForBothSubprocesses = async (subprocessPromises) => {
 };
 
 // node_modules/execa/lib/pipe/streaming.js
-import { finished as finished4 } from "stream/promises";
+var import_promises9 = require("stream/promises");
 var pipeSubprocessStream = (sourceStream, destinationStream, maxListenersController) => {
   const mergedStream = MERGED_STREAMS.has(destinationStream) ? pipeMoreSubprocessStream(sourceStream, destinationStream) : pipeFirstSubprocessStream(sourceStream, destinationStream);
   incrementMaxListeners(sourceStream, SOURCE_LISTENERS_PER_PIPE, maxListenersController.signal);
@@ -6209,7 +6199,7 @@ var pipeMoreSubprocessStream = (sourceStream, destinationStream) => {
 };
 var cleanupMergedStreamsMap = async (destinationStream) => {
   try {
-    await finished4(destinationStream, { cleanup: true, readable: false, writable: true });
+    await (0, import_promises9.finished)(destinationStream, { cleanup: true, readable: false, writable: true });
   } catch {
   }
   MERGED_STREAMS.delete(destinationStream);
@@ -6219,10 +6209,10 @@ var SOURCE_LISTENERS_PER_PIPE = 2;
 var DESTINATION_LISTENERS_PER_PIPE = 1;
 
 // node_modules/execa/lib/pipe/abort.js
-import { aborted } from "util";
+var import_node_util8 = require("util");
 var unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === void 0 ? [] : [unpipeOnSignalAbort(unpipeSignal, unpipeContext)];
 var unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime }) => {
-  await aborted(unpipeSignal, sourceStream);
+  await (0, import_node_util8.aborted)(unpipeSignal, sourceStream);
   await mergedStream.remove(sourceStream);
   const error = new Error("Pipe canceled by `unpipeSignal` option.");
   throw createNonCommandError({
@@ -6293,11 +6283,11 @@ var handlePipePromise = async ({
 var getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);
 
 // node_modules/execa/lib/io/contents.js
-import { setImmediate } from "timers/promises";
+var import_promises10 = require("timers/promises");
 
 // node_modules/execa/lib/io/iterate.js
-import { on as on5 } from "events";
-import { getDefaultHighWaterMark as getDefaultHighWaterMark3 } from "stream";
+var import_node_events12 = require("events");
+var import_node_stream5 = require("stream");
 var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines }) => {
   const controller = new AbortController();
   stopReadingOnExit(subprocess, controller);
@@ -6343,7 +6333,7 @@ var stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
   }
 };
 var iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-  const onStdoutChunk = on5(stream, "data", {
+  const onStdoutChunk = (0, import_node_events12.on)(stream, "data", {
     signal: controller.signal,
     highWaterMark: HIGH_WATER_MARK,
     // Backward compatibility with older name for this option
@@ -6361,7 +6351,7 @@ var iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, sho
     preserveNewlines
   });
 };
-var DEFAULT_OBJECT_HIGH_WATER_MARK = getDefaultHighWaterMark3(true);
+var DEFAULT_OBJECT_HIGH_WATER_MARK = (0, import_node_stream5.getDefaultHighWaterMark)(true);
 var HIGH_WATER_MARK = DEFAULT_OBJECT_HIGH_WATER_MARK;
 var iterateOnData = async function* ({ onStdoutChunk, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) {
   const generators = getGenerators({
@@ -6445,7 +6435,7 @@ var logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixed,
   await logLines(linesIterable, stream, fdNumber, verboseInfo);
 };
 var resumeStream = async (stream) => {
-  await setImmediate();
+  await (0, import_promises10.setImmediate)();
   if (stream.readableFlowing === null) {
     stream.resume();
   }
@@ -6480,14 +6470,14 @@ var getBufferedData = async (streamPromise) => {
 var handleBufferedData = ({ bufferedData }) => isArrayBuffer(bufferedData) ? new Uint8Array(bufferedData) : bufferedData;
 
 // node_modules/execa/lib/resolve/wait-stream.js
-import { finished as finished5 } from "stream/promises";
+var import_promises11 = require("stream/promises");
 var waitForStream = async (stream, fdNumber, streamInfo, { isSameDirection, stopOnExit = false } = {}) => {
   const state = handleStdinDestroy(stream, streamInfo);
   const abortController = new AbortController();
   try {
     await Promise.race([
       ...stopOnExit ? [streamInfo.exitPromise] : [],
-      finished5(stream, { cleanup: true, signal: abortController.signal })
+      (0, import_promises11.finished)(stream, { cleanup: true, signal: abortController.signal })
     ]);
   } catch (error) {
     if (!state.stdinCleanedUp) {
@@ -6602,7 +6592,7 @@ var getAllStream = ({ stdout, stderr, all }, [, bufferStdout, bufferStderr]) =>
 var getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdout.readableObjectMode !== stderr.readableObjectMode;
 
 // node_modules/execa/lib/resolve/wait-subprocess.js
-import { once as once8 } from "events";
+var import_node_events13 = require("events");
 
 // node_modules/execa/lib/verbose/ipc.js
 var shouldLogIpc = (verboseInfo) => isFullVerbose(verboseInfo, "ipc");
@@ -6766,7 +6756,7 @@ var waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors.f
   stopOnExit: type === "native"
 })));
 var throwOnSubprocessError = async (subprocess, { signal }) => {
-  const [error] = await once8(subprocess, "error", { signal });
+  const [error] = await (0, import_node_events13.once)(subprocess, "error", { signal });
   throw error;
 };
 
@@ -6797,11 +6787,11 @@ var waitForConcurrentStreams = async ({ resolve, promises }, subprocess) => {
 };
 
 // node_modules/execa/lib/convert/readable.js
-import { Readable as Readable3 } from "stream";
-import { callbackify as callbackify2 } from "util";
+var import_node_stream6 = require("stream");
+var import_node_util9 = require("util");
 
 // node_modules/execa/lib/convert/shared.js
-import { finished as finished6 } from "stream/promises";
+var import_promises12 = require("stream/promises");
 var safeWaitForSubprocessStdin = async (subprocessStdin) => {
   if (subprocessStdin === void 0) {
     return;
@@ -6821,10 +6811,10 @@ var safeWaitForSubprocessStdout = async (subprocessStdout) => {
   }
 };
 var waitForSubprocessStdin = async (subprocessStdin) => {
-  await finished6(subprocessStdin, { cleanup: true, readable: false, writable: true });
+  await (0, import_promises12.finished)(subprocessStdin, { cleanup: true, readable: false, writable: true });
 };
 var waitForSubprocessStdout = async (subprocessStdout) => {
-  await finished6(subprocessStdout, { cleanup: true, readable: true, writable: false });
+  await (0, import_promises12.finished)(subprocessStdout, { cleanup: true, readable: true, writable: false });
 };
 var waitForSubprocess = async (subprocess, error) => {
   await subprocess;
@@ -6852,9 +6842,9 @@ var createReadable = ({ subprocess, concurrentStreams, encoding }, { from, binar
     encoding,
     preserveNewlines
   });
-  const readable2 = new Readable3({
+  const readable2 = new import_node_stream6.Readable({
     read,
-    destroy: callbackify2(onReadableDestroy.bind(void 0, { subprocessStdout, subprocess, waitReadableDestroy })),
+    destroy: (0, import_node_util9.callbackify)(onReadableDestroy.bind(void 0, { subprocessStdout, subprocess, waitReadableDestroy })),
     highWaterMark: readableHighWaterMark,
     objectMode: readableObjectMode,
     encoding: readableEncoding
@@ -6926,13 +6916,13 @@ var destroyOtherReadable = (stream, error) => {
 };
 
 // node_modules/execa/lib/convert/writable.js
-import { Writable as Writable3 } from "stream";
-import { callbackify as callbackify3 } from "util";
+var import_node_stream7 = require("stream");
+var import_node_util10 = require("util");
 var createWritable = ({ subprocess, concurrentStreams }, { to } = {}) => {
   const { subprocessStdin, waitWritableFinal, waitWritableDestroy } = getSubprocessStdin(subprocess, to, concurrentStreams);
-  const writable2 = new Writable3({
+  const writable2 = new import_node_stream7.Writable({
     ...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
-    destroy: callbackify3(onWritableDestroy.bind(void 0, {
+    destroy: (0, import_node_util10.callbackify)(onWritableDestroy.bind(void 0, {
       subprocessStdin,
       subprocess,
       waitWritableFinal,
@@ -6952,7 +6942,7 @@ var getSubprocessStdin = (subprocess, to, concurrentStreams) => {
 };
 var getWritableMethods = (subprocessStdin, subprocess, waitWritableFinal) => ({
   write: onWrite.bind(void 0, subprocessStdin),
-  final: callbackify3(onWritableFinal.bind(void 0, subprocessStdin, subprocess, waitWritableFinal))
+  final: (0, import_node_util10.callbackify)(onWritableFinal.bind(void 0, subprocessStdin, subprocess, waitWritableFinal))
 });
 var onWrite = (subprocessStdin, chunk, encoding, done) => {
   if (subprocessStdin.write(chunk, encoding)) {
@@ -6992,8 +6982,8 @@ var destroyOtherWritable = (stream, error) => {
 };
 
 // node_modules/execa/lib/convert/duplex.js
-import { Duplex as Duplex3 } from "stream";
-import { callbackify as callbackify4 } from "util";
+var import_node_stream8 = require("stream");
+var import_node_util11 = require("util");
 var createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, binary: binaryOption = true, preserveNewlines = true } = {}) => {
   const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
   const { subprocessStdout, waitReadableDestroy } = getSubprocessStdout(subprocess, from, concurrentStreams);
@@ -7006,10 +6996,10 @@ var createDuplex = ({ subprocess, concurrentStreams, encoding }, { from, to, bin
     encoding,
     preserveNewlines
   });
-  const duplex2 = new Duplex3({
+  const duplex2 = new import_node_stream8.Duplex({
     read,
     ...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
-    destroy: callbackify4(onDuplexDestroy.bind(void 0, {
+    destroy: (0, import_node_util11.callbackify)(onDuplexDestroy.bind(void 0, {
       subprocessStdout,
       subprocessStdin,
       subprocess,
@@ -7146,7 +7136,7 @@ var handleAsyncOptions = ({ timeout, signal, ...options }) => {
 var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors }) => {
   let subprocess;
   try {
-    subprocess = spawn(...concatenateShell(file, commandArguments, options));
+    subprocess = (0, import_node_child_process5.spawn)(...concatenateShell(file, commandArguments, options));
   } catch (error) {
     return handleEarlyError({
       error,
@@ -7159,7 +7149,7 @@ var spawnSubprocessAsync = ({ file, commandArguments, options, startTime, verbos
     });
   }
   const controller = new AbortController();
-  setMaxListeners(Number.POSITIVE_INFINITY, controller.signal);
+  (0, import_node_events14.setMaxListeners)(Number.POSITIVE_INFINITY, controller.signal);
   const originalStreams = [...subprocess.stdio];
   pipeOutputAsync(subprocess, fileDescriptors, controller);
   cleanupOnExit(subprocess, options, controller);
@@ -7395,8 +7385,8 @@ async function runGitDetailed(args, cwd) {
   };
 }
 function normalizeRepoRelativePath(value) {
-  const normalized = path7.posix.normalize(value.replace(/\\/g, "/").trim());
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || path7.posix.isAbsolute(normalized)) {
+  const normalized = import_path2.default.posix.normalize(value.replace(/\\/g, "/").trim());
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || import_path2.default.posix.isAbsolute(normalized)) {
     throw new RemixError("Git returned an invalid repository-relative path.", {
       exitCode: 1,
       hint: `Path: ${value}`
@@ -7405,21 +7395,21 @@ function normalizeRepoRelativePath(value) {
   return normalized;
 }
 function resolveRepoRelativePath(repoRoot, relativePath) {
-  return path7.resolve(repoRoot, ...relativePath.split("/"));
+  return import_path2.default.resolve(repoRoot, ...relativePath.split("/"));
 }
 function isWithinRepoRoot(repoRoot, targetPath) {
-  const relative = path7.relative(repoRoot, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+  const relative = import_path2.default.relative(repoRoot, targetPath);
+  return relative === "" || !relative.startsWith("..") && !import_path2.default.isAbsolute(relative);
 }
 function sha256Hex(value) {
-  return createHash("sha256").update(value).digest("hex");
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
 }
 function resolveGitReportedPath(cwd, reportedPath) {
   const value = reportedPath.trim();
   if (!value) {
     throw new RemixError("Git returned an empty internal path.", { exitCode: 1 });
   }
-  return path7.isAbsolute(value) ? value : path7.resolve(cwd, value);
+  return import_path2.default.isAbsolute(value) ? value : import_path2.default.resolve(cwd, value);
 }
 function parseGitNameStatusZ(stdout) {
   const tokens = stdout.split("\0");
@@ -7490,12 +7480,12 @@ function classifyGitApplyFailure(detail) {
   return "unknown";
 }
 async function pruneEmptyParentDirectories(repoRoot, filePath) {
-  let current = path7.dirname(filePath);
+  let current = import_path2.default.dirname(filePath);
   while (current !== repoRoot && isWithinRepoRoot(repoRoot, current)) {
-    const entries = await fs.readdir(current).catch(() => null);
+    const entries = await import_promises13.default.readdir(current).catch(() => null);
     if (!entries || entries.length > 0) return;
-    await fs.rmdir(current).catch(() => void 0);
-    current = path7.dirname(current);
+    await import_promises13.default.rmdir(current).catch(() => void 0);
+    current = import_path2.default.dirname(current);
   }
 }
 async function findGitRoot(startDir) {
@@ -7550,8 +7540,8 @@ async function getWorkspaceSnapshot(cwd) {
     throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
   }
   const includedUntrackedPaths = Array.from(new Set((await listUntrackedFiles(cwd)).map((entry) => normalizeRepoRelativePath(entry))));
-  const tempDir = await fs.mkdtemp(path7.join(os.tmpdir(), "remix-index-"));
-  const tempIndexPath = path7.join(tempDir, "index");
+  const tempDir = await import_promises13.default.mkdtemp(import_path2.default.join(import_os.default.tmpdir(), "remix-index-"));
+  const tempIndexPath = import_path2.default.join(tempDir, "index");
   const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
   try {
     try {
@@ -7574,14 +7564,14 @@ async function getWorkspaceSnapshot(cwd) {
       });
     }
   } finally {
-    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises13.default.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function writeTempUnifiedDiffBackup(diff, prefix = "remix-add-backup") {
   const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "remix-add-backup";
-  const tmpDir = await fs.mkdtemp(path7.join(os.tmpdir(), `${safePrefix}-`));
-  const backupPath = path7.join(tmpDir, "submitted.diff");
-  await fs.writeFile(backupPath, diff, "utf8");
+  const tmpDir = await import_promises13.default.mkdtemp(import_path2.default.join(import_os.default.tmpdir(), `${safePrefix}-`));
+  const backupPath = import_path2.default.join(tmpDir, "submitted.diff");
+  await import_promises13.default.writeFile(backupPath, diff, "utf8");
   return { backupPath, diffSha256: sha256Hex(diff) };
 }
 async function validateUnifiedDiff(cwd, diff) {
@@ -7598,7 +7588,7 @@ async function validateUnifiedDiff(cwd, diff) {
       detail
     };
   } finally {
-    await fs.rm(path7.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+    await import_promises13.default.rm(import_path2.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
@@ -7618,7 +7608,7 @@ async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
 }
 async function reapplyPreservedWorkspaceChanges(cwd, preserved, operation = "`remix collab add`") {
   const patchFilePath = preserved.preservedDiffPath;
-  const tempPatchHash = await fs.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
+  const tempPatchHash = await import_promises13.default.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
   if (!tempPatchHash) {
     return { status: "failed", detail: "Preserved diff artifact is missing." };
   }
@@ -7750,7 +7740,7 @@ async function discardCapturedUntrackedChanges(repoRoot, capturedPaths) {
         hint: `Path: ${relativePath}`
       });
     }
-    await fs.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
+    await import_promises13.default.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
       throw new RemixError("Failed to remove a captured untracked path before syncing.", {
         exitCode: 1,
         hint: err instanceof Error ? `${relativePath}
@@ -7826,15 +7816,15 @@ function summarizeUnifiedDiff(diff) {
 }
 
 // node_modules/@remixhq/core/dist/collab.js
-import fs3 from "fs/promises";
-import path32 from "path";
-import { createHash as createHash2 } from "crypto";
-import fs4 from "fs/promises";
-import os2 from "os";
-import path8 from "path";
-import fs22 from "fs/promises";
-import os22 from "os";
-import path22 from "path";
+var import_promises14 = __toESM(require("fs/promises"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_crypto2 = require("crypto");
+var import_promises15 = __toESM(require("fs/promises"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_promises16 = __toESM(require("fs/promises"), 1);
+var import_os3 = __toESM(require("os"), 1);
+var import_path5 = __toESM(require("path"), 1);
 function describeBranch(value) {
   const normalized = String(value ?? "").trim();
   return normalized || "(detached)";
@@ -7878,7 +7868,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function buildDeterministicIdempotencyKey(parts) {
-  return createHash2("sha256").update(JSON.stringify(parts)).digest("hex");
+  return (0, import_crypto2.createHash)("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 function formatCliErrorDetail(err) {
   if (err instanceof RemixError) {
@@ -8137,7 +8127,7 @@ function createOwner(params) {
     operation: params.operation,
     repoRoot: params.repoRoot,
     pid: process.pid,
-    hostname: os2.hostname(),
+    hostname: import_os2.default.hostname(),
     startedAt: now,
     heartbeatAt: now,
     version: process.version,
@@ -8145,12 +8135,12 @@ function createOwner(params) {
   };
 }
 async function writeOwnerMetadata(ownerPath, owner) {
-  await fs4.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+  await import_promises15.default.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
 `, "utf8");
 }
 async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await fs4.readFile(ownerPath, "utf8");
+    const raw = await import_promises15.default.readFile(ownerPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
@@ -8172,7 +8162,7 @@ async function readOwnerMetadata(ownerPath) {
 }
 async function isProcessAlive(owner) {
   if (!owner) return null;
-  if (owner.hostname !== os2.hostname()) return null;
+  if (owner.hostname !== import_os2.default.hostname()) return null;
   try {
     process.kill(owner.pid, 0);
     return true;
@@ -8187,23 +8177,23 @@ async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
   if (Number.isFinite(heartbeatMs)) return heartbeatMs;
   const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
   if (Number.isFinite(startedMs)) return startedMs;
-  const stat = await fs4.stat(ownerPath).catch(() => null);
+  const stat = await import_promises15.default.stat(ownerPath).catch(() => null);
   if (stat) return stat.mtimeMs;
-  const dirStat = await fs4.stat(lockDir).catch(() => null);
+  const dirStat = await import_promises15.default.stat(lockDir).catch(() => null);
   if (dirStat) return dirStat.mtimeMs;
   return 0;
 }
 async function ensureLockDir(lockDir) {
-  await fs4.mkdir(path8.dirname(lockDir), { recursive: true });
+  await import_promises15.default.mkdir(import_path4.default.dirname(lockDir), { recursive: true });
 }
 async function tryAcquireLock(lockDir, ownerPath, owner) {
   try {
     await ensureLockDir(lockDir);
-    await fs4.mkdir(lockDir);
+    await import_promises15.default.mkdir(lockDir);
     try {
       await writeOwnerMetadata(ownerPath, owner);
     } catch (error) {
-      await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
     }
     return true;
@@ -8252,7 +8242,7 @@ async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
     const alive = await isProcessAlive(currentOwner2);
     if (ageMs >= options.staleMs && alive !== true) {
       notices.push(buildStaleRecoveryNotice(currentOwner2));
-      await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     await sleep2(RETRY_DELAY_MS);
@@ -8277,7 +8267,7 @@ function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
     };
     owner.heartbeatAt = nextOwner.heartbeatAt;
     void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void fs4.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+    void import_promises15.default.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
   }, heartbeatMs);
 }
 async function releaseReentrantLock(lockDir) {
@@ -8287,12 +8277,12 @@ async function releaseReentrantLock(lockDir) {
   if (held.count > 0) return;
   clearInterval(held.heartbeatTimer);
   heldLocks.delete(lockDir);
-  await fs4.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+  await import_promises15.default.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
 }
 async function withRepoMutationLock(options, fn) {
   const repoRoot = await findGitRoot(options.cwd);
   const gitCommonDir = await getGitCommonDir(repoRoot);
-  const lockDir = path8.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
+  const lockDir = import_path4.default.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
   const owner = createOwner({
     operation: options.operation,
     repoRoot,
@@ -8304,11 +8294,11 @@ async function withRepoMutationLock(options, fn) {
   const existing = heldLocks.get(lockDir);
   let notices = [];
   if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, path8.join(lockDir, "owner.json"), owner, {
+    notices = await acquirePhysicalLock(lockDir, import_path4.default.join(lockDir, "owner.json"), owner, {
       acquireTimeoutMs,
       staleMs
     });
-    const ownerPath = path8.join(lockDir, "owner.json");
+    const ownerPath = import_path4.default.join(lockDir, "owner.json");
     heldLocks.set(lockDir, {
       count: 1,
       lockDir,
@@ -8427,10 +8417,10 @@ async function collabSync(params) {
         allowBranchMismatch: params.allowBranchMismatch,
         operation: "`remix collab sync`"
       });
-      const tempDir = await fs22.mkdtemp(path22.join(os22.tmpdir(), "remix-sync-"));
-      const bundlePath = path22.join(tempDir, "sync-local.bundle");
+      const tempDir = await import_promises16.default.mkdtemp(import_path5.default.join(import_os3.default.tmpdir(), "remix-sync-"));
+      const bundlePath = import_path5.default.join(tempDir, "sync-local.bundle");
       try {
-        await fs22.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
+        await import_promises16.default.writeFile(bundlePath, Buffer.from(bundleBase64, "base64"));
         await importGitBundle(lockedRepoRoot, bundlePath, bundleRef);
         await ensureCommitExists(lockedRepoRoot, sync.targetCommitHash);
         const localCommitHash = await fastForwardToCommit(lockedRepoRoot, sync.targetCommitHash);
@@ -8442,7 +8432,7 @@ async function collabSync(params) {
           ...warnings.length > 0 ? { warnings } : {}
         };
       } finally {
-        await fs22.rm(tempDir, { recursive: true, force: true });
+        await import_promises16.default.rm(tempDir, { recursive: true, force: true });
       }
     }
   );
@@ -8592,7 +8582,7 @@ async function collabAdd(params) {
             const replayResp = await params.api.startChangeStepReplay(binding.currentAppId, {
               prompt,
               assistantResponse: assistantResponse ?? void 0,
-              diff: await fs3.readFile(preserved.preservedDiffPath, "utf8"),
+              diff: await import_promises14.default.readFile(preserved.preservedDiffPath, "utf8"),
               baseCommitHash: preserved.baseHeadCommitHash,
               targetHeadCommitHash: headCommitHash,
               expectedPaths: preserved.stagePlan.expectedPaths,
@@ -8724,7 +8714,7 @@ async function collabAdd(params) {
         dryRun: false,
         allowBranchMismatch: params.allowBranchMismatch
       });
-      await fs3.rm(path32.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+      await import_promises14.default.rm(import_path3.default.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
     } catch (err) {
       const detail = formatCliErrorDetail(err);
       const hint = [
@@ -13193,9 +13183,9 @@ var coerce = {
 var NEVER = INVALID;
 
 // node_modules/@remixhq/core/dist/chunk-EVWDYCBL.js
-import fs5 from "fs/promises";
-import os3 from "os";
-import path9 from "path";
+var import_promises17 = __toESM(require("fs/promises"), 1);
+var import_os4 = __toESM(require("os"), 1);
+var import_path6 = __toESM(require("path"), 1);
 
 // node_modules/tslib/tslib.es6.mjs
 function __rest(s, e) {
@@ -32854,7 +32844,7 @@ var storedSessionSchema = external_exports.object({
 function xdgConfigHome() {
   const value = process.env.XDG_CONFIG_HOME;
   if (typeof value === "string" && value.trim()) return value;
-  return path9.join(os3.homedir(), ".config");
+  return import_path6.default.join(import_os4.default.homedir(), ".config");
 }
 async function maybeLoadKeytar() {
   try {
@@ -32872,22 +32862,22 @@ async function maybeLoadKeytar() {
   return null;
 }
 async function ensurePathPermissions(filePath) {
-  const dir = path9.dirname(filePath);
-  await fs5.mkdir(dir, { recursive: true });
+  const dir = import_path6.default.dirname(filePath);
+  await import_promises17.default.mkdir(dir, { recursive: true });
   try {
-    await fs5.chmod(dir, 448);
+    await import_promises17.default.chmod(dir, 448);
   } catch {
   }
   try {
-    await fs5.chmod(filePath, 384);
+    await import_promises17.default.chmod(filePath, 384);
   } catch {
   }
 }
 async function writeJsonAtomic(filePath, value) {
-  await fs5.mkdir(path9.dirname(filePath), { recursive: true });
+  await import_promises17.default.mkdir(import_path6.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await fs5.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await fs5.rename(tmpPath, filePath);
+  await import_promises17.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises17.default.rename(tmpPath, filePath);
 }
 async function writeSessionFileFallback(filePath, session) {
   await writeJsonAtomic(filePath, session);
@@ -32896,7 +32886,7 @@ async function writeSessionFileFallback(filePath, session) {
 function createLocalSessionStore(params) {
   const service = params?.service?.trim() || "remix-cli";
   const account = params?.account?.trim() || "default";
-  const filePath = params?.filePath?.trim() || path9.join(xdgConfigHome(), "remix", "session.json");
+  const filePath = params?.filePath?.trim() || import_path6.default.join(xdgConfigHome(), "remix", "session.json");
   return {
     async getSession() {
       const keytar = await maybeLoadKeytar();
@@ -32910,7 +32900,7 @@ function createLocalSessionStore(params) {
           return null;
         }
       }
-      const raw = await fs5.readFile(filePath, "utf8").catch(() => null);
+      const raw = await import_promises17.default.readFile(filePath, "utf8").catch(() => null);
       if (!raw) return null;
       try {
         const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
@@ -33096,27 +33086,27 @@ async function createHookCollabApiClient() {
 }
 
 // src/hook-state.ts
-import fs6 from "fs/promises";
-import os4 from "os";
-import path10 from "path";
-import { randomUUID } from "crypto";
+var import_promises18 = __toESM(require("fs/promises"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
 function stateRoot() {
-  return path10.join(os4.tmpdir(), "remix-claude-plugin-hooks");
+  return import_node_path6.default.join(import_node_os4.default.tmpdir(), "remix-claude-plugin-hooks");
 }
 function statePath(sessionId) {
-  return path10.join(stateRoot(), `${sessionId}.json`);
+  return import_node_path6.default.join(stateRoot(), `${sessionId}.json`);
 }
 function stateLockPath(sessionId) {
-  return path10.join(stateRoot(), `${sessionId}.lock`);
+  return import_node_path6.default.join(stateRoot(), `${sessionId}.lock`);
 }
 function stateLockMetaPath(sessionId) {
-  return path10.join(stateLockPath(sessionId), "owner.json");
+  return import_node_path6.default.join(stateLockPath(sessionId), "owner.json");
 }
 async function writeJsonAtomic2(filePath, value) {
-  await fs6.mkdir(path10.dirname(filePath), { recursive: true });
+  await import_promises18.default.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await fs6.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await fs6.rename(tmpPath, filePath);
+  await import_promises18.default.writeFile(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await import_promises18.default.rename(tmpPath, filePath);
 }
 var STATE_LOCK_WAIT_MS = 2e3;
 var STATE_LOCK_POLL_MS = 25;
@@ -33126,7 +33116,7 @@ async function sleep4(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function readStateLockMetadata(sessionId) {
-  const raw = await fs6.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises18.default.readFile(stateLockMetaPath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -33151,13 +33141,13 @@ async function tryRemoveStaleStateLock(sessionId) {
   const metadata = await readStateLockMetadata(sessionId);
   const staleByHeartbeat = metadata && Date.now() - new Date(metadata.heartbeatAt).getTime() > STATE_LOCK_STALE_MS;
   if (staleByHeartbeat) {
-    await fs6.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
     return true;
   }
   if (!metadata) {
-    const lockStat = await fs6.stat(lockPath).catch(() => null);
+    const lockStat = await import_promises18.default.stat(lockPath).catch(() => null);
     if (lockStat && Date.now() - lockStat.mtimeMs > STATE_LOCK_STALE_MS) {
-      await fs6.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
       return true;
     }
   }
@@ -33168,8 +33158,8 @@ async function acquireStateLock(sessionId) {
   const deadline = Date.now() + STATE_LOCK_WAIT_MS;
   while (true) {
     try {
-      await fs6.mkdir(lockPath);
-      const ownerId = randomUUID();
+      await import_promises18.default.mkdir(lockPath);
+      const ownerId = (0, import_node_crypto.randomUUID)();
       const createdAt = (/* @__PURE__ */ new Date()).toISOString();
       const metadata = {
         ownerId,
@@ -33193,7 +33183,7 @@ async function acquireStateLock(sessionId) {
         clearInterval(heartbeat);
         const currentMetadata = await readStateLockMetadata(sessionId);
         if (currentMetadata?.ownerId === ownerId) {
-          await fs6.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+          await import_promises18.default.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
         }
       };
     } catch (error) {
@@ -33276,7 +33266,7 @@ async function updatePendingTurnState(sessionId, updater) {
   });
 }
 async function loadPendingTurnState(sessionId) {
-  const raw = await fs6.readFile(statePath(sessionId), "utf8").catch(() => null);
+  const raw = await import_promises18.default.readFile(statePath(sessionId), "utf8").catch(() => null);
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -33351,25 +33341,67 @@ async function listTouchedRepos(sessionId) {
 }
 async function clearPendingTurnState(sessionId) {
   await withStateLock(sessionId, async () => {
-    await fs6.rm(statePath(sessionId), { force: true }).catch(() => void 0);
+    await import_promises18.default.rm(statePath(sessionId), { force: true }).catch(() => void 0);
   });
 }
 
+// package.json
+var package_default = {
+  name: "@remixhq/claude-plugin",
+  version: "0.1.9",
+  description: "Claude Code plugin for Remix collaboration workflows",
+  homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/RemixDotOne/remix-claude-plugin.git"
+  },
+  type: "module",
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist",
+    ".claude-plugin/plugin.json",
+    ".mcp.json",
+    "skills",
+    "hooks",
+    "agents"
+  ],
+  scripts: {
+    build: "tsup",
+    postbuild: `node -e "const fs=require('node:fs'); for (const p of ['dist/mcp-server.cjs','dist/hook-pre-git.cjs','dist/hook-user-prompt.cjs','dist/hook-post-collab.cjs','dist/hook-stop-collab.cjs']) fs.chmodSync(p, 0o755);"`,
+    dev: "tsx src/mcp-server.ts",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    prepack: "npm run build"
+  },
+  dependencies: {
+    "@remixhq/core": "^0.1.7",
+    "@remixhq/mcp": "^0.1.7"
+  },
+  devDependencies: {
+    "@types/node": "^25.4.0",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  }
+};
+
 // src/metadata.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
 var pluginMetadata = {
-  name: pkg.name,
-  version: pkg.version,
-  description: pkg.description,
+  name: package_default.name,
+  version: package_default.version,
+  description: package_default.description,
   pluginId: "remix",
   agentName: "remix-collab"
 };
 
 // src/hook-utils.ts
-import fs7 from "fs/promises";
-import path11 from "path";
+var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 async function readJsonStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -33586,4 +33618,4 @@ main().catch((error) => {
 `);
   process.exitCode = 0;
 });
-//# sourceMappingURL=hook-stop-collab.js.map
+//# sourceMappingURL=hook-stop-collab.cjs.map