@lousy-agents/cli 5.17.2 → 5.17.4

package/dist/index.js

@@ -551,7 +551,7 @@ module.exports = function extend() {
 
 },
 8078(module) {
-function webpackEmptyAsyncContext(req) {
+function __rspack_empty_async_context(req) {
   // Here Promise.resolve().then() is used instead of new Promise() to prevent
   // uncaught exception popping up in devtools
   return Promise.resolve().then(function() {
@@ -560,10 +560,10 @@ function webpackEmptyAsyncContext(req) {
     throw e;
   });
 }
-webpackEmptyAsyncContext.keys = () => ([]);
-webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
-webpackEmptyAsyncContext.id = 8078;
-module.exports = webpackEmptyAsyncContext;
+__rspack_empty_async_context.keys = () => ([]);
+__rspack_empty_async_context.resolve = __rspack_empty_async_context;
+__rspack_empty_async_context.id = 8078;
+module.exports = __rspack_empty_async_context;
 
 
 },
@@ -1009,7 +1009,15 @@ const parseRepeatedExtglob = (pattern, requireEnd = true) => {
   }
 };
 
-const getStarExtglobSequenceOutput = pattern => {
+const buildCharClassStar = chars => {
+  const source = chars.length === 1
+    ? utils.escapeRegex(chars[0])
+    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+  return `${source}*`;
+};
+
+const getStarExtglobSequenceChars = pattern => {
   let index = 0;
   const chars = [];
 
@@ -1038,11 +1046,7 @@ const getStarExtglobSequenceOutput = pattern => {
     return;
   }
 
-  const source = chars.length === 1
-    ? utils.escapeRegex(chars[0])
-    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
-
-  return `${source}*`;
+  return chars;
 };
 
 const repeatedExtglobRecursion = pattern => {
@@ -1081,17 +1085,43 @@ const analyzeRepeatedExtglob = (body, options) => {
     }
   }
 
+  // A repeated extglob is "risky" (prone to catastrophic backtracking) when a
+  // branch is itself a `*(...)` sequence, since that nests an unbounded quantifier
+  // inside the outer `+(...)`/`*(...)`. When *every* branch reduces to single
+  // characters we can emit one flat, ReDoS-safe character class that preserves the
+  // meaning of ALL branches (e.g. `+(*(a)|*(b))` -> `[ab]*`), rather than dropping
+  // every branch but the first.
+  const safeChars = [];
+  let sawStarSequence = false;
+  let combinable = true;
+
   for (const branch of branches) {
-    const safeOutput = getStarExtglobSequenceOutput(branch);
-    if (safeOutput) {
-      return { risky: true, safeOutput };
+    const chars = getStarExtglobSequenceChars(branch);
+    if (chars) {
+      sawStarSequence = true;
+      safeChars.push(...chars);
+      continue;
+    }
+
+    const literal = normalizeSimpleBranch(branch);
+    if (literal && literal.length === 1) {
+      safeChars.push(literal);
+      continue;
     }
 
+    combinable = false;
+
     if (repeatedExtglobRecursion(branch) > max) {
       return { risky: true };
     }
   }
 
+  if (sawStarSequence) {
+    return combinable
+      ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) }
+      : { risky: true };
+  }
+
   return { risky: false };
 };
 
@@ -2189,6 +2219,18 @@ const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
  * const isMatch = picomatch('*.!(*a)');
  * console.log(isMatch('a.a')); //=> false
  * console.log(isMatch('a.b')); //=> true
+ *
+ * // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+ * const picomatch = require('picomatch/posix');
+ * // the same API, defaulting to posix paths
+ * const isMatch = picomatch('a/*');
+ * console.log(isMatch('a\\b')); //=> false
+ * console.log(isMatch('a/b')); //=> true
+ *
+ * // you can still configure the matcher function to accept windows paths
+ * const isMatch = picomatch('a/*', { options: windows });
+ * console.log(isMatch('a\\b')); //=> true
+ * console.log(isMatch('a/b')); //=> true
  * ```
  * @name picomatch
  * @param {String|Array} `globs` One or more glob patterns.
@@ -2326,9 +2368,9 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch.matchBase = (input, glob, options) => {
+picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
   const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(utils.basename(input));
+  return regex.test(utils.basename(input, { windows: posix }));
 };
 
 /**
@@ -19128,8 +19170,6 @@ const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
 var lib_main = __webpack_require__(5599);
 // EXTERNAL MODULE: external "node:assert"
 var external_node_assert_ = __webpack_require__(4589);
-// EXTERNAL MODULE: external "node:v8"
-var external_node_v8_ = __webpack_require__(8877);
 ;// CONCATENATED MODULE: ../../node_modules/exsolve/dist/index.mjs
 
 
@@ -19137,9 +19177,6 @@ var external_node_v8_ = __webpack_require__(8877);
 
 
 
-
-
-//#region src/internal/builtins.ts
 const nodeBuiltins = [
 	"_http_agent",
 	"_http_client",
@@ -19210,12 +19247,8 @@ const nodeBuiltins = [
 	"worker_threads",
 	"zlib"
 ];
-
-//#endregion
-//#region src/internal/errors.ts
-const own$1 = {}.hasOwnProperty;
 const classRegExp = /^([A-Z][a-z\d]*)+$/;
-const kTypes = new Set([
+const kTypes = /* @__PURE__ */ new Set([
 	"string",
 	"function",
 	"number",
@@ -19227,83 +19260,95 @@ const kTypes = new Set([
 	"symbol"
 ]);
 const messages = /* @__PURE__ */ new Map();
-const nodeInternalPrefix = "__node_internal_";
-let userStackTraceLimit;
-/**
-* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
-* We cannot use Intl.ListFormat because it's not available in
-* --without-intl builds.
-*
-* @param {Array<string>} array
-*   An array of strings.
-* @param {string} [type]
-*   The list type to be inserted before the last element.
-* @returns {string}
-*/
 function formatList(array, type = "and") {
-	return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
+	switch (array.length) {
+		case 0: return "";
+		case 1: return `${array[0]}`;
+		case 2: return `${array[0]} ${type} ${array[1]}`;
+		case 3: return `${array[0]}, ${array[1]}, ${type} ${array[2]}`;
+		default: return `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
+	}
+}
+function getExpectedArgumentLength(message) {
+	let expectedLength = 0;
+	const regex = /%[dfijoOs]/g;
+	while (regex.exec(message) !== null) expectedLength++;
+	return expectedLength;
 }
-/**
-* Utility function for registering the error codes.
-*/
 function createError(sym, value, constructor) {
 	messages.set(sym, value);
 	return makeNodeErrorWithCode(constructor, sym);
 }
+const kIsNodeError = Symbol("kIsNodeError");
 function makeNodeErrorWithCode(Base, key) {
-	return function NodeError(...parameters) {
-		const limit = Error.stackTraceLimit;
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
-		const error = new Base();
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
-		const message = getMessage(key, parameters, error);
-		Object.defineProperties(error, {
-			message: {
-				value: message,
-				enumerable: false,
-				writable: true,
-				configurable: true
-			},
-			toString: {
-				value() {
+	const message = messages.get(key);
+	const expectedLength = typeof message === "string" ? getExpectedArgumentLength(message) : -1;
+	switch (expectedLength) {
+		case 0: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					external_node_assert_.ok(args.length === 0, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+					super(message);
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
 					return `${this.name} [${key}]: ${this.message}`;
-				},
-				enumerable: false,
-				writable: true,
-				configurable: true
+				}
 			}
-		});
-		captureLargerStackTrace(error);
-		error.code = key;
-		return error;
-	};
-}
-function isErrorStackTraceLimitWritable() {
-	try {
-		if (external_node_v8_.startupSnapshot.isBuildingSnapshot()) return false;
-	} catch {}
-	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-	if (desc === void 0) return Object.isExtensible(Error);
-	return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
-}
-/**
-* This function removes unnecessary frames from Node.js core errors.
-*/
-function hideStackFrames(wrappedFunction) {
-	const hidden = nodeInternalPrefix + wrappedFunction.name;
-	Object.defineProperty(wrappedFunction, "name", { value: hidden });
-	return wrappedFunction;
-}
-const captureLargerStackTrace = hideStackFrames(function(error) {
-	const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-	if (stackTraceLimitIsWritable) {
-		userStackTraceLimit = Error.stackTraceLimit;
-		Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+			return NodeError;
+		}
+		case -1: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					super();
+					Object.defineProperty(this, "message", {
+						value: getMessage(key, args, this),
+						enumerable: false,
+						writable: true,
+						configurable: true
+					});
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
+					return `${this.name} [${key}]: ${this.message}`;
+				}
+			}
+			return NodeError;
+		}
+		default: {
+			class NodeError extends Base {
+				code = key;
+				constructor(...args) {
+					external_node_assert_.ok(args.length === expectedLength, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+					args.unshift(message);
+					super(Reflect.apply(external_node_util_.format, null, args));
+				}
+				get ["constructor"]() {
+					return Base;
+				}
+				get [kIsNodeError]() {
+					return true;
+				}
+				toString() {
+					return `${this.name} [${key}]: ${this.message}`;
+				}
+			}
+			return NodeError;
+		}
 	}
-	Error.captureStackTrace(error);
-	if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-	return error;
-});
+}
 function getMessage(key, parameters, self) {
 	const message = messages.get(key);
 	external_node_assert_.ok(message !== void 0, "expected `message` to be found");
@@ -19311,29 +19356,44 @@ function getMessage(key, parameters, self) {
 		external_node_assert_.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`);
 		return Reflect.apply(message, self, parameters);
 	}
-	const regex = /%[dfijoOs]/g;
-	let expectedLength = 0;
-	while (regex.exec(message) !== null) expectedLength++;
+	const expectedLength = getExpectedArgumentLength(message);
 	external_node_assert_.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`);
 	if (parameters.length === 0) return message;
 	parameters.unshift(message);
 	return Reflect.apply(external_node_util_.format, null, parameters);
 }
-/**
-* Determine the specific type of a value for type-mismatch errors.
-*/
 function determineSpecificType(value) {
-	if (value === null || value === void 0) return String(value);
-	if (typeof value === "function" && value.name) return `function ${value.name}`;
-	if (typeof value === "object") {
-		if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
-		return `${(0,external_node_util_.inspect)(value, { depth: -1 })}`;
+	if (value === null) return "null";
+	else if (value === void 0) return "undefined";
+	const type = typeof value;
+	switch (type) {
+		case "bigint": return `type bigint (${value}n)`;
+		case "number":
+			if (value === 0) return 1 / value === Number.NEGATIVE_INFINITY ? "type number (-0)" : "type number (0)";
+			else if (Number.isNaN(value)) return "type number (NaN)";
+			else if (value === Number.POSITIVE_INFINITY) return "type number (Infinity)";
+			else if (value === Number.NEGATIVE_INFINITY) return "type number (-Infinity)";
+			return `type number (${value})`;
+		case "boolean": return value ? "type boolean (true)" : "type boolean (false)";
+		case "symbol": return `type symbol (${String(value)})`;
+		case "function": return `function ${value.name}`;
+		case "object":
+			if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
+			return `${(0,external_node_util_.inspect)(value, { depth: -1 })}`;
+		case "string": {
+			let string = value;
+			if (string.length > 28) string = `${string.slice(0, 25)}...`;
+			if (!string.includes("'")) return `type string ('${string}')`;
+			return `type string (${JSON.stringify(string)})`;
+		}
+		default: {
+			let inspected = (0,external_node_util_.inspect)(value, { colors: false });
+			if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+			return `type ${type} (${inspected})`;
+		}
 	}
-	let inspected = (0,external_node_util_.inspect)(value, { colors: false });
-	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
-	return `type ${typeof value} (${inspected})`;
 }
-const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
+createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
 	external_node_assert_.ok(typeof name === "string", "'name' must be a string");
 	if (!Array.isArray(expected)) expected = [expected];
 	let message = "The ";
@@ -19357,7 +19417,7 @@ const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected
 	if (instances.length > 0) {
 		const pos = types.indexOf("object");
 		if (pos !== -1) {
-			types.slice(pos, 1);
+			types.splice(pos, 1);
 			instances.push("Object");
 		}
 	}
@@ -19377,20 +19437,11 @@ const ERR_INVALID_ARG_TYPE = createError("ERR_INVALID_ARG_TYPE", (name, expected
 	message += `. Received ${determineSpecificType(actual)}`;
 	return message;
 }, TypeError);
-const ERR_INVALID_MODULE_SPECIFIER = createError(
-	"ERR_INVALID_MODULE_SPECIFIER",
-	/**
-	* @param {string} request
-	* @param {string} reason
-	* @param {string} [base]
-	*/
-	(request, reason, base) => {
-		return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
-	},
-	TypeError
-);
-const ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path$1, base, message) => {
-	return `Invalid package config ${path$1}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+const ERR_INVALID_MODULE_SPECIFIER = createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base) => {
+	return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+}, TypeError);
+const ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path, base, message) => {
+	return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
 }, Error);
 const ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (packagePath, key, target, isImport = false, base) => {
 	const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
@@ -19400,39 +19451,30 @@ const ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (pa
 	}
 	return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
 }, Error);
-const ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path$1, base, exactUrl = false) => {
-	return `Cannot find ${exactUrl ? "module" : "package"} '${path$1}' imported from ${base}`;
+const ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", function(path, base, exactUrl = false) {
+	if (exactUrl && typeof exactUrl === "string") this.url = `${exactUrl}`;
+	return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
 }, Error);
-const ERR_NETWORK_IMPORT_DISALLOWED = createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
 const ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
 	return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
 }, TypeError);
-const ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
-	"ERR_PACKAGE_PATH_NOT_EXPORTED",
-	/**
-	* @param {string} packagePath
-	* @param {string} subpath
-	* @param {string} [base]
-	*/
-	(packagePath, subpath, base) => {
-		if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-		return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-	},
-	Error
-);
-const ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+const ERR_PACKAGE_PATH_NOT_EXPORTED = createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (packagePath, subpath, base) => {
+	if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+	return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+}, Error);
+const ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", function(path, base, exactUrl = void 0) {
+	this.url = exactUrl;
+	return `Directory import '${path}' is not supported resolving ES modules imported from ${base}`;
+}, Error);
 const ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", "Failed to resolve module specifier \"%s\" from \"%s\": Invalid relative URL or base scheme is not hierarchical.", TypeError);
-const ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path$1) => {
-	return `Unknown file extension "${extension}" for ${path$1}`;
+const ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path) => {
+	return `Unknown file extension "${extension}" for ${path}`;
 }, TypeError);
-const ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
 	let inspected = (0,external_node_util_.inspect)(value);
 	if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
 	return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
 }, TypeError);
-
-//#endregion
-//#region src/internal/package-json-reader.ts
 const hasOwnProperty$1 = {}.hasOwnProperty;
 const dist_cache = /* @__PURE__ */ new Map();
 function read(jsonPath, { base, specifier }) {
@@ -19489,9 +19531,6 @@ function getPackageScopeConfig(resolved) {
 		type: "none"
 	};
 }
-
-//#endregion
-//#region src/internal/get-format.ts
 const dist_hasOwnProperty = {}.hasOwnProperty;
 const extensionFormatMap = {
 	__proto__: null,
@@ -19510,33 +19549,25 @@ const protocolHandlers = {
 	"node:": () => "builtin"
 };
 function mimeToFormat(mime) {
-	if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)) return "module";
+	if (mime && /^\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?$/i.test(mime)) return "module";
 	if (mime === "application/json") return "json";
 	return null;
 }
 function getDataProtocolModuleFormat(parsed) {
-	const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [
+	const { 1: mime } = /^([^/]+\/[^;,]+)(?:[^,]*?)(;base64)?,/.exec(parsed.pathname) || [
 		null,
 		null,
 		null
 	];
 	return mimeToFormat(mime);
 }
-/**
-* Returns the file extension from a URL.
-*
-* Should give similar result to
-* `require('node:path').extname(require('node:url').fileURLToPath(url))`
-* when used with a `file:` URL.
-*
-*/
+const DOT_CODE = 46;
+const SLASH_CODE = 47;
 function dist_extname(url) {
 	const pathname = url.pathname;
-	let index = pathname.length;
-	while (index--) {
-		const code = pathname.codePointAt(index);
-		if (code === 47) return "";
-		if (code === 46) return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+	for (let i = pathname.length - 1; i > 0; i--) switch (pathname.charCodeAt(i)) {
+		case SLASH_CODE: return "";
+		case DOT_CODE: return pathname.charCodeAt(i - 1) === SLASH_CODE ? "" : pathname.slice(i);
 	}
 	return "";
 }
@@ -19549,11 +19580,12 @@ function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
 	}
 	if (ext === "") {
 		const { type: packageType } = getPackageScopeConfig(url);
-		if (packageType === "none" || packageType === "commonjs") return "commonjs";
-		return "module";
+		if (packageType === "module") return "module";
+		if (packageType !== "none") return packageType;
+		return "commonjs";
 	}
-	const format$1 = extensionFormatMap[ext];
-	if (format$1) return format$1;
+	const format = extensionFormatMap[ext];
+	if (format) return format;
 	if (ignoreErrors) return;
 	throw new ERR_UNKNOWN_FILE_EXTENSION(ext, (0,external_node_url_.fileURLToPath)(url));
 }
@@ -19562,9 +19594,6 @@ function defaultGetFormatWithoutErrors(url, context) {
 	if (!dist_hasOwnProperty.call(protocolHandlers, protocol)) return null;
 	return protocolHandlers[protocol](url, context, true) || null;
 }
-
-//#endregion
-//#region src/internal/resolve.ts
 const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
 const own = {}.hasOwnProperty;
 const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
@@ -19589,19 +19618,11 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 	if (!main) external_node_process_.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
 	else if (external_node_path_.resolve(packagePath, main) !== urlPath) external_node_process_.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
 }
-function tryStatSync(path$1) {
+function tryStatSync(path) {
 	try {
-		return (0,external_node_fs_.statSync)(path$1);
+		return (0,external_node_fs_.statSync)(path);
 	} catch {}
 }
-/**
-* Legacy CommonJS main resolution:
-* 1. let M = pkg_url + (json main field)
-* 2. TRY(M, M.js, M.json, M.node)
-* 3. TRY(M/index.js, M/index.json, M/index.node)
-* 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
-* 5. NOT_FOUND
-*/
 function dist_fileExists(url) {
 	const stats = (0,external_node_fs_.statSync)(url, { throwIfNoEntry: false });
 	const isFile = stats ? stats.isFile() : void 0;
@@ -19612,7 +19633,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 	if (packageConfig.main !== void 0) {
 		guess = new external_node_url_.URL(packageConfig.main, packageJsonUrl);
 		if (dist_fileExists(guess)) return guess;
-		const tries$1 = [
+		const tries = [
 			`./${packageConfig.main}.js`,
 			`./${packageConfig.main}.json`,
 			`./${packageConfig.main}.node`,
@@ -19620,9 +19641,9 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
 			`./${packageConfig.main}/index.json`,
 			`./${packageConfig.main}/index.node`
 		];
-		let i$1 = -1;
-		while (++i$1 < tries$1.length) {
-			guess = new external_node_url_.URL(tries$1[i$1], packageJsonUrl);
+		let i = -1;
+		while (++i < tries.length) {
+			guess = new external_node_url_.URL(tries[i], packageJsonUrl);
 			if (dist_fileExists(guess)) break;
 			guess = void 0;
 		}
@@ -19754,7 +19775,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 			}
 			return resolveResult;
 		}
-		if (lastException === void 0 || lastException === null) return null;
+		if (lastException === void 0 || lastException === null) return lastException;
 		throw lastException;
 	}
 	if (typeof target === "object" && target !== null) {
@@ -19774,7 +19795,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
 				return resolveResult;
 			}
 		}
-		return null;
+		return;
 	}
 	if (target === null) return null;
 	throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
@@ -19848,7 +19869,7 @@ function patternKeyCompare(a, b) {
 	return 0;
 }
 function packageImportsResolve(name, base, conditions) {
-	if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", (0,external_node_url_.fileURLToPath)(base));
+	if (name === "#" || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", (0,external_node_url_.fileURLToPath)(base));
 	let packageJsonUrl;
 	const packageConfig = getPackageScopeConfig(base);
 	if (packageConfig.exists) {
@@ -19882,10 +19903,6 @@ function packageImportsResolve(name, base, conditions) {
 	}
 	throw importNotDefined(name, packageJsonUrl, base);
 }
-/**
-* @param {string} specifier
-* @param {URL} base
-*/
 function parsePackageName(specifier, base) {
 	let separatorIndex = specifier.indexOf("/");
 	let validPackageName = true;
@@ -19920,12 +19937,12 @@ function packageResolve(specifier, base, conditions) {
 			packageJsonPath = (0,external_node_url_.fileURLToPath)(packageJsonUrl);
 			continue;
 		}
-		const packageConfig$1 = read(packageJsonPath, {
+		const packageConfig = read(packageJsonPath, {
 			base,
 			specifier
 		});
-		if (packageConfig$1.exports !== void 0 && packageConfig$1.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig$1, base, conditions);
-		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig$1, base);
+		if (packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig, base);
 		return new external_node_url_.URL(packageSubpath, packageJsonUrl);
 	} while (packageJsonPath.length !== lastPath.length);
 	// removed by dead control flow
@@ -19943,21 +19960,6 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
 	if (specifier[0] === "/") return true;
 	return isRelativeSpecifier(specifier);
 }
-/**
-* The “Resolver Algorithm Specification” as detailed in the Node docs (which is
-* sync and slightly lower-level than `resolve`).
-*
-* @param {string} specifier
-*   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
-* @param {URL} base
-*   Full URL (to a file) that `specifier` is resolved relative from.
-* @param {Set<string>} [conditions]
-*   Conditions.
-* @param {boolean} [preserveSymlinks]
-*   Keep symlinks instead of resolving them.
-* @returns {URL}
-*   A URL object to the found thing.
-*/
 function moduleResolve(specifier, base, conditions, preserveSymlinks) {
 	const protocol = base.protocol;
 	const isData = protocol === "data:";
@@ -19984,19 +19986,10 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
 	if (resolved.protocol !== "file:") return resolved;
 	return finalizeResolution(resolved, base, preserveSymlinks);
 }
-
-//#endregion
-//#region src/resolve.ts
-const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-const dist_isWindows = /* @__PURE__ */ (() => process.platform === "win32")();
-const globalCache = /* @__PURE__ */ (() => globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map())();
-/**
-* Synchronously resolves a module url based on the options provided.
-*
-* @param {string} input - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
+const DEFAULT_CONDITIONS_SET = /* #__PURE__ */ new Set(["node", "import"]);
+const DEFAULT_CONDITIONS_KEY = "2:6:import4:node";
+const dist_isWindows = /* #__PURE__ */ (() => process.platform === "win32")();
+const globalCache = /* #__PURE__ */ (() => globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map())();
 function resolveModuleURL(input, options) {
 	const parsedInput = _parseInput(input);
 	if ("external" in parsedInput) return parsedInput.external;
@@ -20061,15 +20054,6 @@ function resolveModuleURL(input, options) {
 	if (cacheObj) cacheObj.set(cacheKey, resolved.href);
 	return resolved.href;
 }
-/**
-* Synchronously resolves a module then converts it to a file path
-*
-* (throws error if reolved path is not file:// scheme)
-*
-* @param {string} id - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
 function resolveModulePath(id, options) {
 	const resolved = resolveModuleURL(id, options);
 	if (!resolved) return;
@@ -20129,21 +20113,31 @@ function _fmtPath(input) {
 		return input;
 	}
 }
-function _cacheKey(id, opts) {
-	return JSON.stringify([
-		id,
-		(opts?.conditions || ["node", "import"]).sort(),
-		opts?.extensions,
-		opts?.from,
-		opts?.suffixes
-	]);
+function _cacheKey(id, options) {
+	let from;
+	if (Array.isArray(options?.from)) from = options.from;
+	else if (options?.from) from = [options.from];
+	return _cacheKeyValues([id]) + _conditionsKey(options?.conditions) + _cacheKeyValues(options?.extensions) + _cacheKeyValues(from) + _cacheKeyValues(options?.suffixes);
+}
+function _conditionsKey(conditions) {
+	if (!conditions) return DEFAULT_CONDITIONS_KEY;
+	return _cacheKeyValues([...new Set(conditions)].sort());
+}
+function _cacheKeyValues(values) {
+	if (!values) return "-";
+	let key = `${values.length}:`;
+	for (const value of values) {
+		const stringValue = String(value);
+		key += `${stringValue.length}:${stringValue}`;
+	}
+	return key;
 }
 function _join(a, b) {
 	if (!a || !b || b === "/") return a;
 	return (a.endsWith("/") ? a : a + "/") + (b.startsWith("/") ? b.slice(1) : b);
 }
-function _normalizeWinPath(path$1) {
-	return path$1.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
+function _normalizeWinPath(path) {
+	return path.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
 }
 function _isURL(input) {
 	return input instanceof URL || input?.constructor?.name === "URL";
@@ -20175,7 +20169,6 @@ function _parseInput(input) {
 	throw new TypeError("id must be a `string` or `URL`");
 }
 
-//#endregion
 
 // EXTERNAL MODULE: external "node:module"
 var external_node_module_ = __webpack_require__(8995);
@@ -22378,15 +22371,270 @@ const originalStringify = JSON.stringify;
 const originalParse = JSON.parse;
 const customFormat = /^-?\d+n$/;
 
-const bigIntsStringify = /([\[:])?"(-?\d+)n"($|([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
-const noiseStringify =
-  /([\[:])?("-?\d+n+)n("$|"([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
+const bigIntsStringify = /([\[:])?"(-?\d+)n"($|\s*[,\}\]])/g;
+const noiseStringify = /([\[:])?("-?\d+n+)n("$|"\s*[,\}\]])/g;
 
 /**
  * @typedef {(this: any, key: string | number | undefined, value: any) => any} Replacer
  * @typedef {(key: string | number | undefined, value: any, context?: { source: string }) => any} Reviver
  */
 
+/**
+ * Checks if a value is unstringifiable according to native JSON.stringify rules.
+ *
+ * @param {any} val The value to check.
+ * @returns {boolean} True if the value is undefined, a function, or a symbol.
+ */
+const isUnstringifiable = (val) =>
+  val === undefined || typeof val === "function" || typeof val === "symbol";
+
+/**
+ * Checks if a value is a native JSON.rawJSON object (Node.js 22+).
+ *
+ * @param {any} val The value to check.
+ * @returns {boolean} True if the value is a RawJSON instance.
+ */
+const isRawJSON = (val) =>
+  val !== null &&
+  typeof val === "object" &&
+  val.constructor &&
+  val.constructor.name === "RawJSON";
+
+/**
+ * Iteratively converts a JS value to a JSON string.
+ * Used as a fallback when the native JSON.stringify hits the Maximum Call Stack size.
+ * Fully compliant with JSON formatting (space), replacers, and toJSON behaviors.
+ *
+ * @param {any} rootValue The value to stringify.
+ * @param {Replacer | Array<string | number> | null} [replacer] User's custom replacer function.
+ * @param {string | number} [spaceParam] Indentation for pretty-printing.
+ * @returns {string | undefined} The generated JSON string.
+ */
+const stringifyIteratively = (rootValue, replacer, spaceParam) => {
+  let space = "";
+
+  if (typeof spaceParam === "number") {
+    space = " ".repeat(Math.min(10, Math.max(0, Math.floor(spaceParam))));
+  } else if (typeof spaceParam === "string") {
+    space = spaceParam.slice(0, 10);
+  }
+
+  const isFunctionReplacer = typeof replacer === "function";
+  const propertyList = Array.isArray(replacer)
+    ? new Set(replacer.map(String))
+    : null;
+
+  /**
+   * Prepares a value for stringification by resolving toJSON, handling BigInts,
+   * applying custom replacers, and unwrapping primitive objects.
+   *
+   * @param {object|Array} parent The parent object or array holding the value.
+   * @param {string} key The key associated with the value.
+   * @param {any} val The raw value to process.
+   * @returns {any} The processed value ready for stringification.
+   */
+  const prepareVal = (parent, key, val) => {
+    const isObject = val !== null && typeof val === "object";
+    const hasToJSON = isObject && typeof val.toJSON === "function";
+
+    if (hasToJSON) {
+      val = val.toJSON(key);
+    }
+
+    const isNoise = typeof val === "string" && noiseValue.test(val);
+
+    if (isNoise) return val + "n";
+
+    const isBigInt = typeof val === "bigint";
+
+    if (isBigInt) {
+      const supportsRawJSON = "rawJSON" in JSON;
+
+      if (supportsRawJSON) return JSON.rawJSON(val.toString());
+
+      return val.toString() + "n";
+    }
+
+    if (isFunctionReplacer) {
+      val = replacer.call(parent, key, val);
+    }
+
+    const isPostReplacerObject = val !== null && typeof val === "object";
+
+    if (isPostReplacerObject) {
+      const isPrimitiveWrapper =
+        val instanceof Number ||
+        val instanceof String ||
+        val instanceof Boolean;
+
+      if (isPrimitiveWrapper) {
+        val = val.valueOf();
+      }
+    }
+
+    return val;
+  };
+
+  const rootProcessed = prepareVal({ "": rootValue }, "", rootValue);
+
+  if (isUnstringifiable(rootProcessed)) {
+    return undefined;
+  }
+
+  const isRootPrimitive =
+    rootProcessed === null || typeof rootProcessed !== "object";
+  const isRootNativeRawJSON = isRawJSON(rootProcessed);
+
+  if (isRootPrimitive || isRootNativeRawJSON) {
+    return originalStringify(rootProcessed);
+  }
+
+  const chunks = [];
+  let level = 0;
+
+  const stack = [
+    {
+      parent: { "": rootProcessed },
+      key: "",
+      val: rootProcessed,
+      isArray: Array.isArray(rootProcessed),
+      keys: Array.isArray(rootProcessed) ? null : Object.keys(rootProcessed),
+      index: 0,
+      first: true,
+    },
+  ];
+
+  const visited = new WeakSet([rootProcessed]);
+
+  while (stack.length > 0) {
+    const node = stack[stack.length - 1];
+
+    if (node.index === 0) {
+      chunks.push(node.isArray ? "[" : "{");
+      level++;
+    }
+
+    let isDone = false;
+
+    if (node.isArray) {
+      if (node.index < node.val.length) {
+        if (!node.first) chunks.push(",");
+
+        if (space) chunks.push("\n" + space.repeat(level));
+
+        const childRaw = node.val[node.index];
+        const childVal = prepareVal(node.val, String(node.index), childRaw);
+
+        if (isUnstringifiable(childVal)) {
+          chunks.push("null");
+          node.first = false;
+          node.index++;
+        } else {
+          const isComplexObject =
+            childVal !== null && typeof childVal === "object";
+          const isNativeRaw = isRawJSON(childVal);
+
+          if (isComplexObject && !isNativeRaw) {
+            if (visited.has(childVal)) {
+              throw new TypeError("Converting circular structure to JSON");
+            }
+
+            visited.add(childVal);
+
+            stack.push({
+              parent: node.val,
+              key: String(node.index),
+              val: childVal,
+              isArray: Array.isArray(childVal),
+              keys: Array.isArray(childVal) ? null : Object.keys(childVal),
+              index: 0,
+              first: true,
+            });
+
+            node.first = false;
+            node.index++;
+          } else {
+            chunks.push(originalStringify(childVal));
+            node.first = false;
+            node.index++;
+          }
+        }
+      } else {
+        isDone = true;
+      }
+    } else {
+      while (node.index < node.keys.length) {
+        const k = node.keys[node.index++];
+
+        const isFilteredOutByArray = propertyList && !propertyList.has(k);
+
+        if (isFilteredOutByArray) continue;
+
+        const childRaw = node.val[k];
+        const childVal = prepareVal(node.val, k, childRaw);
+
+        if (isUnstringifiable(childVal)) continue;
+
+        if (!node.first) chunks.push(",");
+
+        if (space) {
+          chunks.push("\n" + space.repeat(level) + originalStringify(k) + ": ");
+        } else {
+          chunks.push(originalStringify(k) + ":");
+        }
+
+        const isComplexObject =
+          childVal !== null && typeof childVal === "object";
+        const isNativeRaw = isRawJSON(childVal);
+
+        if (isComplexObject && !isNativeRaw) {
+          if (visited.has(childVal)) {
+            throw new TypeError("Converting circular structure to JSON");
+          }
+
+          visited.add(childVal);
+
+          stack.push({
+            parent: node.val,
+            key: k,
+            val: childVal,
+            isArray: Array.isArray(childVal),
+            keys: Array.isArray(childVal) ? null : Object.keys(childVal),
+            index: 0,
+            first: true,
+          });
+
+          node.first = false;
+
+          break; // Stop current loop level to process the newly pushed stack node
+        } else {
+          chunks.push(originalStringify(childVal));
+          node.first = false;
+        }
+      }
+
+      const isNodeFullyProcessed =
+        node.index >= node.keys.length && stack[stack.length - 1] === node;
+
+      if (isNodeFullyProcessed) {
+        isDone = true;
+      }
+    }
+
+    if (isDone) {
+      level--;
+
+      if (!node.first && space) chunks.push("\n" + space.repeat(level));
+
+      chunks.push(node.isArray ? "]" : "}");
+      visited.delete(node.val);
+      stack.pop();
+    }
+  }
+
+  return chunks.join("");
+};
+
 /**
  * Converts a JavaScript value to a JSON string.
  *
@@ -22398,55 +22646,87 @@ const noiseStringify =
  *
  * @param {*} value The value to convert to a JSON string.
  * @param {Replacer | Array<string | number> | null} [replacer]
- *   A function that alters the behavior of the stringification process,
- *   or an array of strings/numbers to indicate properties to exclude.
+ * A function that alters the behavior of the stringification process,
+ * or an array of strings/numbers to indicate properties to exclude.
  * @param {string | number} [space]
- *   A string or number to specify indentation or pretty-printing.
+ * A string or number to specify indentation or pretty-printing.
  * @returns {string} The JSON string representation.
  */
 const JSONStringify = (value, replacer, space) => {
-  if ("rawJSON" in JSON) {
-    return originalStringify(
+  try {
+    const supportsRawJSON = "rawJSON" in JSON;
+
+    if (supportsRawJSON) {
+      return originalStringify(
+        value,
+        (key, val) => {
+          if (typeof val === "bigint") return JSON.rawJSON(val.toString());
+
+          const hasFunctionReplacer = typeof replacer === "function";
+
+          if (hasFunctionReplacer) return replacer(key, val);
+
+          const isKeyInArrayReplacer =
+            Array.isArray(replacer) && replacer.includes(key);
+
+          if (isKeyInArrayReplacer) return val;
+
+          return val;
+        },
+        space,
+      );
+    }
+
+    if (!value) return originalStringify(value, replacer, space);
+
+    const convertedToCustomJSON = originalStringify(
       value,
-      (key, value) => {
-        if (typeof value === "bigint") return JSON.rawJSON(value.toString());
+      (key, val) => {
+        const isNoise = typeof val === "string" && noiseValue.test(val);
 
-        if (typeof replacer === "function") return replacer(key, value);
+        if (isNoise) return val.toString() + "n"; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
 
-        if (Array.isArray(replacer) && replacer.includes(key)) return value;
+        if (typeof val === "bigint") return val.toString() + "n";
 
-        return value;
+        const hasFunctionReplacer = typeof replacer === "function";
+
+        if (hasFunctionReplacer) return replacer(key, val);
+
+        const isKeyInArrayReplacer =
+          Array.isArray(replacer) && replacer.includes(key);
+
+        if (isKeyInArrayReplacer) return val;
+
+        return val;
       },
       space,
     );
-  }
 
-  if (!value) return originalStringify(value, replacer, space);
+    const processedJSON = convertedToCustomJSON.replace(
+      bigIntsStringify,
+      "$1$2$3",
+    ); // Delete one "n" off the end of every BigInt value
 
-  const convertedToCustomJSON = originalStringify(
-    value,
-    (key, value) => {
-      const isNoise = typeof value === "string" && noiseValue.test(value);
+    const denoisedJSON = processedJSON.replace(noiseStringify, "$1$2$3"); // Remove one "n" off the end of every noisy string
 
-      if (isNoise) return value.toString() + "n"; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+    return denoisedJSON;
+  } catch (error) {
+    if (error instanceof RangeError) {
+      const convertedJSON = stringifyIteratively(value, replacer, space);
 
-      if (typeof value === "bigint") return value.toString() + "n";
+      if (convertedJSON === undefined) return undefined;
 
-      if (typeof replacer === "function") return replacer(key, value);
+      const supportsRawJSON = "rawJSON" in JSON;
 
-      if (Array.isArray(replacer) && replacer.includes(key)) return value;
+      if (supportsRawJSON) return convertedJSON;
 
-      return value;
-    },
-    space,
-  );
-  const processedJSON = convertedToCustomJSON.replace(
-    bigIntsStringify,
-    "$1$2$3",
-  ); // Delete one "n" off the end of every BigInt value
-  const denoisedJSON = processedJSON.replace(noiseStringify, "$1$2$3"); // Remove one "n" off the end of every noisy string
+      const processedJSON = convertedJSON.replace(bigIntsStringify, "$1$2$3");
 
-  return denoisedJSON;
+      return processedJSON.replace(noiseStringify, "$1$2$3");
+    }
+
+    throw error;
+  }
 };
 
 const featureCache = new Map();
@@ -22494,12 +22774,15 @@ const isContextSourceSupported = () => {
 const convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
   const isCustomFormatBigInt =
     typeof value === "string" && customFormat.test(value);
+
   if (isCustomFormatBigInt) return BigInt(value.slice(0, -1));
 
   const isNoiseValue = typeof value === "string" && noiseValue.test(value);
   if (isNoiseValue) return value.slice(0, -1);
 
-  if (typeof userReviver !== "function") return value;
+  const hasUserReviver = typeof userReviver === "function";
+
+  if (!hasUserReviver) return value;
 
   return userReviver(key, value, context);
 };
@@ -22517,15 +22800,18 @@ const convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
  */
 const JSONParseV2 = (text, reviver) => {
   return JSON.parse(text, (key, value, context) => {
-    const isBigNumber =
-      typeof value === "number" &&
-      (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER);
+    const isNumber = typeof value === "number";
+    const isOutOfBounds =
+      value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER;
+    const isBigNumber = isNumber && isOutOfBounds;
     const isInt = context && intRegex.test(context.source);
     const isBigInt = isBigNumber && isInt;
 
     if (isBigInt) return BigInt(context.source);
 
-    if (typeof reviver !== "function") return value;
+    const hasCustomReviver = typeof reviver === "function";
+
+    if (!hasCustomReviver) return value;
 
     return reviver(key, value, context);
   });
@@ -22537,6 +22823,105 @@ const stringsOrLargeNumbers =
   /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
 const noiseValueWithQuotes = /^"-?\d+n+"$/; // Noise - strings that match the custom format before being converted to it
 
+/**
+ * Iteratively traverses the parsed object bottom-up (post-order),
+ * emulating the native JSON.parse reviver behavior.
+ * This avoids Call Stack overflows (RangeError) on deeply nested structures.
+ *
+ * @param {any} parsed The natively parsed JSON object.
+ * @param {Reviver} [userReviver] User's custom reviver function.
+ * @returns {any} The fully processed object.
+ */
+const applyReviverIteratively = (parsed, userReviver) => {
+  const rootHolder = { "": parsed };
+  const stack = [{ parent: rootHolder, key: "", visited: false }];
+
+  while (stack.length > 0) {
+    const node = stack[stack.length - 1];
+
+    if (!node.visited) {
+      node.visited = true;
+
+      const value = node.parent[node.key];
+      const isComplexObject = value !== null && typeof value === "object";
+
+      if (isComplexObject) {
+        const keys = Object.keys(value);
+
+        for (let i = keys.length - 1; i >= 0; i--) {
+          stack.push({ parent: value, key: keys[i], visited: false });
+        }
+      }
+    } else {
+      const { parent, key } = node;
+      let value = parent[key];
+
+      if (typeof value === "string") {
+        const isCustomFormatBigInt = customFormat.test(value);
+
+        if (isCustomFormatBigInt) {
+          value = BigInt(value.slice(0, -1));
+        } else {
+          const isNoise = noiseValue.test(value);
+
+          if (isNoise) value = value.slice(0, -1);
+        }
+      }
+
+      const hasUserReviver = typeof userReviver === "function";
+
+      if (hasUserReviver) {
+        value = userReviver.call(parent, key, value);
+      }
+
+      const isDeleted = value === undefined;
+
+      if (isDeleted) {
+        delete parent[key];
+      } else {
+        parent[key] = value;
+      }
+
+      stack.pop();
+    }
+  }
+
+  return rootHolder[""];
+};
+
+/**
+ * Pre-processes the JSON string to mark large numbers with an 'n' suffix.
+ *
+ * @param {string} text The raw JSON string.
+ * @returns {string} The serialized string with marked BigInts.
+ */
+const serializeBigInts = (text) => {
+  return text.replace(
+    stringsOrLargeNumbers,
+    (match, digits, fractional, exponential) => {
+      const isString = match[0] === '"';
+      const isNoise = isString && noiseValueWithQuotes.test(match);
+
+      if (isNoise) return match.substring(0, match.length - 1) + 'n"'; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+
+      const hasFractionalOrExponential = fractional || exponential;
+
+      // With a fixed number of digits, we can correctly use lexicographical comparison to do a numeric comparison
+      const isLessThanMaxSafeInt =
+        digits &&
+        (digits.length < MAX_DIGITS ||
+          (digits.length === MAX_DIGITS && digits <= MAX_INT));
+
+      const isStandardValue =
+        isString || hasFractionalOrExponential || isLessThanMaxSafeInt;
+
+      if (isStandardValue) return match;
+
+      return '"' + match + 'n"';
+    },
+  );
+};
+
 /**
  * Converts a JSON string into a JavaScript value.
  *
@@ -22548,42 +22933,34 @@ const noiseValueWithQuotes = /^"-?\d+n+"$/; // Noise - strings that match the cu
  *
  * @param {string} text A valid JSON string.
  * @param {Reviver} [reviver]
- *   A function that transforms the results. This function is called for each member
- *   of the object. If a member contains nested objects, the nested objects are
- *   transformed before the parent object is.
+ * A function that transforms the results. This function is called for each member
+ * of the object. If a member contains nested objects, the nested objects are
+ * transformed before the parent object is.
  * @returns {any} The parsed JavaScript value.
  * @throws {SyntaxError} If text is not valid JSON.
  */
 const JSONParse = (text, reviver) => {
   if (!text) return originalParse(text, reviver);
 
-  if (isContextSourceSupported()) return JSONParseV2(text, reviver); // Shortcut to a faster (2x) and simpler version
-
-  // Find and mark big numbers with "n"
-  const serializedData = text.replace(
-    stringsOrLargeNumbers,
-    (text, digits, fractional, exponential) => {
-      const isString = text[0] === '"';
-      const isNoise = isString && noiseValueWithQuotes.test(text);
-
-      if (isNoise) return text.substring(0, text.length - 1) + 'n"'; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+  try {
+    if (isContextSourceSupported()) return JSONParseV2(text, reviver); // Shortcut to a faster (2x) and simpler version
 
-      const isFractionalOrExponential = fractional || exponential;
-      const isLessThanMaxSafeInt =
-        digits &&
-        (digits.length < MAX_DIGITS ||
-          (digits.length === MAX_DIGITS && digits <= MAX_INT)); // With a fixed number of digits, we can correctly use lexicographical comparison to do a numeric comparison
+    // Find and mark big numbers with "n"
+    const serializedData = serializeBigInts(text);
 
-      if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
-        return text;
+    return originalParse(serializedData, (key, value, context) =>
+      convertMarkedBigIntsReviver(key, value, context, reviver),
+    );
+  } catch (error) {
+    if (error instanceof RangeError) {
+      const serializedData = serializeBigInts(text);
+      const parsed = originalParse(serializedData);
 
-      return '"' + text + 'n"';
-    },
-  );
+      return applyReviverIteratively(parsed, reviver);
+    }
 
-  return originalParse(serializedData, (key, value, context) =>
-    convertMarkedBigIntsReviver(key, value, context, reviver),
-  );
+    throw error;
+  }
 };
 
 
@@ -22637,7 +23014,7 @@ class RequestError extends Error {
 
 
 // pkg/dist-src/version.js
-var dist_bundle_VERSION = "10.0.10";
+var dist_bundle_VERSION = "10.0.11";
 
 // pkg/dist-src/defaults.js
 var defaults_default = {
@@ -22794,9 +23171,10 @@ function toErrorMessage(data) {
   if (data instanceof ArrayBuffer) {
     return "Unknown error";
   }
-  if ("message" in data) {
-    const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : "";
-    return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`;
+  if (typeof data === "object" && data !== null && "message" in data) {
+    const objectData = data;
+    const suffix = "documentation_url" in objectData ? ` - ${objectData.documentation_url}` : "";
+    return Array.isArray(objectData.errors) ? `${objectData.message}: ${objectData.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${objectData.message}${suffix}`;
   }
   return `Unknown error: ${JSON.stringify(data)}`;
 }
@@ -29078,6 +29456,7 @@ async function enumerateMcpServers(repoRoot) {
 
 
 
+
 const MAX_FILE_BYTES = 1_048_576;
 const SCANNABLE_EXTENSIONS = new Set([
     ".md",
@@ -29180,44 +29559,97 @@ function resolveEdge(rawTarget, type, sourceAbsPath, repoRoot, existingAbsPaths)
         malformed: false
     };
 }
-async function collectFiles(repoRoot, relDir, collected, depth = 0) {
+/**
+ * fs-safe's listing/reading rejects symlinks outright, so a symlinked
+ * instruction file or directory (e.g. a repo-root AGENTS.md pointing at a
+ * canonical doc) is reported as neither a file nor a directory and silently
+ * disappears from the scan. Resolve the target ourselves and only follow it
+ * when it stays inside the repo root, mirroring the traversal guard already
+ * used for edge targets. Stats the already-resolved real path (rather than
+ * re-resolving the symlink) so the within-root check and the type check
+ * observe the same target, closing the TOCTOU window between the two.
+ */ async function resolveSymlink(rootReal, entryAbs) {
+    try {
+        const real = await (0,promises_.realpath)(entryAbs);
+        const isWithinRoot = real === rootReal || real.startsWith(`${rootReal}${external_node_path_.sep}`);
+        if (!isWithinRoot) return null;
+        const targetStat = await (0,promises_.stat)(real);
+        if (targetStat.isDirectory()) return {
+            kind: "directory",
+            real
+        };
+        if (targetStat.isFile()) return {
+            kind: "file",
+            real
+        };
+        return null;
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Walks the repo tree, tracking two coordinate systems in parallel:
+ *  - (listRoot, listRelDir): where fs-safe should actually list/read from.
+ *    This starts at topRepoRoot but re-roots to rootReal + a real relative
+ *    path once the walk crosses a symlinked directory, since fs-safe cannot
+ *    list a path that is itself a symlink.
+ *  - logicalPrefix: the repo-root-relative path as it appears in the tree,
+ *    used for InventoryRecord.path/absPath so a file's identity reflects
+ *    where it's *referenced from*, not where the symlink target physically
+ *    lives.
+ */ async function collectFiles(listRoot, listRelDir, logicalPrefix, topRepoRoot, rootReal, collected, depth = 0) {
     if (depth > 10) return;
     let entries;
     try {
-        entries = await file_system_utils_listDirectoryWithinRoot(repoRoot, relDir);
+        entries = await file_system_utils_listDirectoryWithinRoot(listRoot, listRelDir);
     } catch  {
         return;
     }
     entries.sort((a, b)=>a.name.localeCompare(b.name));
     for (const entry of entries){
-        const entryRel = relDir ? `${relDir}/${entry.name}` : entry.name;
-        const entryAbs = (0,external_node_path_.resolve)(repoRoot, entryRel);
-        if (entry.isDirectory()) {
+        const listEntryRel = listRelDir ? `${listRelDir}/${entry.name}` : entry.name;
+        const logicalRel = logicalPrefix ? `${logicalPrefix}/${entry.name}` : entry.name;
+        const listEntryAbs = (0,external_node_path_.resolve)(listRoot, listEntryRel);
+        const isDirectory = entry.isDirectory();
+        const isFile = entry.isFile();
+        const symlink = entry.isSymbolicLink() ? await resolveSymlink(rootReal, listEntryAbs) : null;
+        if (isDirectory || symlink?.kind === "directory") {
             if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
                 continue;
             }
-            await collectFiles(repoRoot, entryRel, collected, depth + 1);
-        } else if (entry.isFile() && isScannableFile(entry.name)) {
+            if (symlink?.kind === "directory") {
+                // Re-root the walk at rootReal so the symlinked directory
+                // (and anything beneath it) is listed via its real,
+                // symlink-free path — fs-safe rejects listing a path that
+                // is itself a symlink.
+                await collectFiles(rootReal, (0,external_node_path_.relative)(rootReal, symlink.real), logicalRel, topRepoRoot, rootReal, collected, depth + 1);
+            } else {
+                await collectFiles(listRoot, listEntryRel, logicalRel, topRepoRoot, rootReal, collected, depth + 1);
+            }
+        } else if ((isFile || symlink?.kind === "file") && isScannableFile(entry.name)) {
             collected.push({
-                absPath: entryAbs,
-                relPath: entryRel
+                absPath: (0,external_node_path_.resolve)(topRepoRoot, logicalRel),
+                relPath: logicalRel,
+                readRoot: symlink?.kind === "file" ? rootReal : listRoot,
+                readRelPath: symlink?.kind === "file" ? (0,external_node_path_.relative)(rootReal, symlink.real) : listEntryRel
             });
         }
     }
 }
 async function scanRepository(repoRoot) {
     const absRoot = (0,external_node_path_.resolve)(repoRoot);
+    const rootReal = await (0,promises_.realpath)(absRoot);
     const allFiles = [];
-    await collectFiles(absRoot, "", allFiles);
+    await collectFiles(absRoot, "", "", absRoot, rootReal, allFiles);
     const existingAbsPaths = new Set(allFiles.map((f)=>f.absPath));
     const rawRecords = [];
-    for (const { absPath, relPath } of allFiles){
+    for (const { absPath, relPath, readRoot, readRelPath } of allFiles){
         const harness = determineHarness(relPath);
         if (harness === null) continue;
         let content = null;
         if (isMarkdownFile(relPath)) {
             try {
-                content = await file_system_utils_readTextWithinRoot(absRoot, relPath, MAX_FILE_BYTES);
+                content = await file_system_utils_readTextWithinRoot(readRoot, readRelPath, MAX_FILE_BYTES);
             } catch  {
                 content = null;
             }
@@ -61584,8 +62016,8 @@ __webpack_require__.r = (exports) => {
       // object to store loaded and loading chunks
       // undefined = chunk not loaded, null = chunk preloaded/prefetched
       // [resolve, Promise] = chunk loading, 0 = chunk loaded
-      var installedChunks = {410: 0,};
-      var installChunk = (data) => {
+      var moduleInstalledChunks = {410: 0,};
+      var moduleInstallChunk = (data) => {
     var __rspack_esm_ids = data.__rspack_esm_ids;
     var moreModules = data.__webpack_modules__;
     var __rspack_esm_runtime = data.__rspack_esm_runtime;
@@ -61600,17 +62032,17 @@ __webpack_require__.r = (exports) => {
     if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
     for (; i < __rspack_esm_ids.length; i++) {
         chunkId = __rspack_esm_ids[i];
-        if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
-            installedChunks[chunkId][0]();
+        if (__webpack_require__.o(moduleInstalledChunks, chunkId) && moduleInstalledChunks[chunkId]) {
+            moduleInstalledChunks[chunkId][0]();
         }
-        installedChunks[__rspack_esm_ids[i]] = 0;
+        moduleInstalledChunks[__rspack_esm_ids[i]] = 0;
     }
     
 };
 
         __webpack_require__.f.j = function (chunkId, promises) {
           // import() chunk loading for javascript
-var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
+var installedChunkData = __webpack_require__.o(moduleInstalledChunks, chunkId) ? moduleInstalledChunks[chunkId] : undefined;
 if (installedChunkData !== 0) { // 0 means "already installed".'
     // a Promise means "currently loading".
     if (installedChunkData) {
@@ -61618,18 +62050,19 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
     } else {
         if (true) {
             // setup Promise in chunk cache
-            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e) => {
-                if (installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(moduleInstallChunk, (e) => {
+                if (moduleInstalledChunks[chunkId] !== 0) moduleInstalledChunks[chunkId] = undefined;
                 throw e;
             });
             var promise = Promise.race([promise, new Promise((resolve) => {
-                installedChunkData = installedChunks[chunkId] = [resolve];
+                installedChunkData = moduleInstalledChunks[chunkId] = [resolve];
             })]);
             promises.push(installedChunkData[1] = promise);
         }
         
     }
 }
+
         }
         // no external install chunk
 // no on chunks loaded