@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/primordials/math.js

@@ -11,7 +11,7 @@ const require_smol_primordial = require('../smol/primordial.js');
 *   stock `Math.X` since they are pre-computed scalar values with no fast-path
 *   benefit.
 */
-const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
+const smolPrimordial = require_smol_primordial.getSmolPrimordial();
 const MathE = Math.E;
 const MathLN2 = Math.LN2;
 const MathLN10 = Math.LN10;
@@ -20,42 +20,42 @@ const MathLOG10E = Math.LOG10E;
 const MathPI = Math.PI;
 const MathSQRT1_2 = Math.SQRT1_2;
 const MathSQRT2 = Math.SQRT2;
-const MathAbs = _smolPrimordial?.mathAbs ?? Math.abs;
-const MathAcos = _smolPrimordial?.mathAcos ?? Math.acos;
-const MathAcosh = _smolPrimordial?.mathAcosh ?? Math.acosh;
-const MathAsin = _smolPrimordial?.mathAsin ?? Math.asin;
-const MathAsinh = _smolPrimordial?.mathAsinh ?? Math.asinh;
-const MathAtan = _smolPrimordial?.mathAtan ?? Math.atan;
-const MathAtan2 = _smolPrimordial?.mathAtan2 ?? Math.atan2;
-const MathAtanh = _smolPrimordial?.mathAtanh ?? Math.atanh;
-const MathCbrt = _smolPrimordial?.mathCbrt ?? Math.cbrt;
-const MathCeil = _smolPrimordial?.mathCeil ?? Math.ceil;
-const MathClz32 = _smolPrimordial?.mathClz32 ?? Math.clz32;
-const MathCos = _smolPrimordial?.mathCos ?? Math.cos;
-const MathCosh = _smolPrimordial?.mathCosh ?? Math.cosh;
-const MathExp = _smolPrimordial?.mathExp ?? Math.exp;
-const MathExpm1 = _smolPrimordial?.mathExpm1 ?? Math.expm1;
+const MathAbs = smolPrimordial?.mathAbs ?? Math.abs;
+const MathAcos = smolPrimordial?.mathAcos ?? Math.acos;
+const MathAcosh = smolPrimordial?.mathAcosh ?? Math.acosh;
+const MathAsin = smolPrimordial?.mathAsin ?? Math.asin;
+const MathAsinh = smolPrimordial?.mathAsinh ?? Math.asinh;
+const MathAtan = smolPrimordial?.mathAtan ?? Math.atan;
+const MathAtan2 = smolPrimordial?.mathAtan2 ?? Math.atan2;
+const MathAtanh = smolPrimordial?.mathAtanh ?? Math.atanh;
+const MathCbrt = smolPrimordial?.mathCbrt ?? Math.cbrt;
+const MathCeil = smolPrimordial?.mathCeil ?? Math.ceil;
+const MathClz32 = smolPrimordial?.mathClz32 ?? Math.clz32;
+const MathCos = smolPrimordial?.mathCos ?? Math.cos;
+const MathCosh = smolPrimordial?.mathCosh ?? Math.cosh;
+const MathExp = smolPrimordial?.mathExp ?? Math.exp;
+const MathExpm1 = smolPrimordial?.mathExpm1 ?? Math.expm1;
 const MathF16round = Math.f16round;
-const MathFloor = _smolPrimordial?.mathFloor ?? Math.floor;
-const MathFround = _smolPrimordial?.mathFround ?? Math.fround;
-const MathHypot = _smolPrimordial?.mathHypot ?? Math.hypot;
-const MathImul = _smolPrimordial?.mathImul ?? Math.imul;
-const MathLog = _smolPrimordial?.mathLog ?? Math.log;
-const MathLog1p = _smolPrimordial?.mathLog1p ?? Math.log1p;
-const MathLog2 = _smolPrimordial?.mathLog2 ?? Math.log2;
-const MathLog10 = _smolPrimordial?.mathLog10 ?? Math.log10;
+const MathFloor = smolPrimordial?.mathFloor ?? Math.floor;
+const MathFround = smolPrimordial?.mathFround ?? Math.fround;
+const MathHypot = smolPrimordial?.mathHypot ?? Math.hypot;
+const MathImul = smolPrimordial?.mathImul ?? Math.imul;
+const MathLog = smolPrimordial?.mathLog ?? Math.log;
+const MathLog1p = smolPrimordial?.mathLog1p ?? Math.log1p;
+const MathLog2 = smolPrimordial?.mathLog2 ?? Math.log2;
+const MathLog10 = smolPrimordial?.mathLog10 ?? Math.log10;
 const MathMax = Math.max;
 const MathMin = Math.min;
-const MathPow = _smolPrimordial?.mathPow ?? Math.pow;
+const MathPow = smolPrimordial?.mathPow ?? Math.pow;
 const MathRandom = Math.random;
-const MathRound = _smolPrimordial?.mathRound ?? Math.round;
-const MathSign = _smolPrimordial?.mathSign ?? Math.sign;
-const MathSin = _smolPrimordial?.mathSin ?? Math.sin;
-const MathSinh = _smolPrimordial?.mathSinh ?? Math.sinh;
-const MathSqrt = _smolPrimordial?.mathSqrt ?? Math.sqrt;
-const MathTan = _smolPrimordial?.mathTan ?? Math.tan;
-const MathTanh = _smolPrimordial?.mathTanh ?? Math.tanh;
-const MathTrunc = _smolPrimordial?.mathTrunc ?? Math.trunc;
+const MathRound = smolPrimordial?.mathRound ?? Math.round;
+const MathSign = smolPrimordial?.mathSign ?? Math.sign;
+const MathSin = smolPrimordial?.mathSin ?? Math.sin;
+const MathSinh = smolPrimordial?.mathSinh ?? Math.sinh;
+const MathSqrt = smolPrimordial?.mathSqrt ?? Math.sqrt;
+const MathTan = smolPrimordial?.mathTan ?? Math.tan;
+const MathTanh = smolPrimordial?.mathTanh ?? Math.tanh;
+const MathTrunc = smolPrimordial?.mathTrunc ?? Math.trunc;
 
 //#endregion
 exports.MathAbs = MathAbs;

package/dist/primordials/number.js

@@ -11,7 +11,7 @@ const require_smol_primordial = require('../smol/primordial.js');
 *   static `parseFloat` / `parseInt` use the FastOneByteString-typed bindings
 *   for ASCII inputs and fall back to stock `Number.parse*` otherwise.
 */
-const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
+const smolPrimordial = require_smol_primordial.getSmolPrimordial();
 const NumberCtor = Number;
 const NumberEPSILON = Number.EPSILON;
 const NumberMAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
@@ -20,14 +20,14 @@ const NumberMIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 const NumberMIN_VALUE = Number.MIN_VALUE;
 const NumberNEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
 const NumberPOSITIVE_INFINITY = Number.POSITIVE_INFINITY;
-const NumberIsFinite = _smolPrimordial?.numberIsFinite ?? Number.isFinite;
-const NumberIsInteger = _smolPrimordial?.numberIsInteger ?? Number.isInteger;
-const NumberIsNaN = _smolPrimordial?.numberIsNaN ?? Number.isNaN;
-const NumberIsSafeInteger = _smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
-const NumberParseFloat = _smolPrimordial?.numberParseFloat ?? Number.parseFloat;
-const _smolParseInt10 = _smolPrimordial?.numberParseInt10;
-/* c8 ignore start */
-const NumberParseInt = _smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? _smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
+const NumberIsFinite = smolPrimordial?.numberIsFinite ?? Number.isFinite;
+const NumberIsInteger = smolPrimordial?.numberIsInteger ?? Number.isInteger;
+const NumberIsNaN = smolPrimordial?.numberIsNaN ?? Number.isNaN;
+const NumberIsSafeInteger = smolPrimordial?.numberIsSafeInteger ?? Number.isSafeInteger;
+const NumberParseFloat = smolPrimordial?.numberParseFloat ?? Number.parseFloat;
+const smolParseInt10 = smolPrimordial?.numberParseInt10;
+/* c8 ignore start - smol fast-path branch only reachable on socket-btm smol Node binary */
+const NumberParseInt = smolParseInt10 ? (s, radix) => radix === void 0 || radix === 10 ? smolParseInt10(s) : Number.parseInt(s, radix) : Number.parseInt;
 /* c8 ignore stop */
 const NumberPrototypeToExponential = require_primordials_uncurry.uncurryThis(Number.prototype.toExponential);
 const NumberPrototypeToFixed = require_primordials_uncurry.uncurryThis(Number.prototype.toFixed);

package/dist/primordials/object.js

@@ -40,11 +40,11 @@ const ObjectPrototypeIsPrototypeOf = require_primordials_uncurry.uncurryThis(Obj
 const ObjectPrototypePropertyIsEnumerable = require_primordials_uncurry.uncurryThis(Object.prototype.propertyIsEnumerable);
 const ObjectPrototypeToString = require_primordials_uncurry.uncurryThis(Object.prototype.toString);
 const ObjectPrototypeValueOf = require_primordials_uncurry.uncurryThis(Object.prototype.valueOf);
-const _objectProto = Object.prototype;
-const ObjectPrototypeDefineGetter = require_primordials_uncurry.uncurryThis(_objectProto.__defineGetter__);
-const ObjectPrototypeDefineSetter = require_primordials_uncurry.uncurryThis(_objectProto.__defineSetter__);
-const ObjectPrototypeLookupGetter = require_primordials_uncurry.uncurryThis(_objectProto.__lookupGetter__);
-const ObjectPrototypeLookupSetter = require_primordials_uncurry.uncurryThis(_objectProto.__lookupSetter__);
+const objectProto = Object.prototype;
+const ObjectPrototypeDefineGetter = require_primordials_uncurry.uncurryThis(objectProto.__defineGetter__);
+const ObjectPrototypeDefineSetter = require_primordials_uncurry.uncurryThis(objectProto.__defineSetter__);
+const ObjectPrototypeLookupGetter = require_primordials_uncurry.uncurryThis(objectProto.__lookupGetter__);
+const ObjectPrototypeLookupSetter = require_primordials_uncurry.uncurryThis(objectProto.__lookupSetter__);
 
 //#endregion
 exports.ObjectAssign = ObjectAssign;

package/dist/primordials/process.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @file Safe call-through accessors for the `process` global's methods and
+ *   value reads. The `process` object reference is captured once at module load
+ *   (immune to a later `globalThis.process = …` reassignment), but each method
+ *   is CALLED at access time off that captured object — so `vi.spyOn(process,
+ *   'cwd')`, which mutates the same captured object, still intercepts. Binding
+ *   the method reference instead (`process.cwd.bind(process)`) would freeze it
+ *   and break that test seam, so we deliberately keep the late call. Consumers
+ *   read cwd / platform / env / argv through these instead of touching
+ *   `process` directly; enforced fleet-wide by
+ *   `socket/prefer-process-primordial`. This is the `process` leaf of the
+ *   node-module primordials: where `node/fs` / `node/path` lazy-load a `node:`
+ *   module behind a function, this captures the always-present `process` global
+ *   and routes its hot reads through one tamper-resistant surface.
+ */
+/**
+ * The CPU architecture token (`'x64'` / `'arm64'` / …).
+ */
+export declare function processArch(): string;
+/**
+ * The argv array (`[execPath, scriptPath, ...args]`).
+ *
+ * @example
+ *   ;```typescript
+ *   const entry = processArgv()[1]
+ *   ```
+ */
+export declare function processArgv(): string[];
+/**
+ * The current working directory. Call-through to the captured process's `cwd` —
+ * late-bound so test spies still intercept.
+ *
+ * @example
+ *   ;```typescript
+ *   const dir = processCwd()
+ *   ```
+ */
+export declare function processCwd(): string;
+/**
+ * Emit a process warning. Call-through so a test spy on `process.emitWarning`
+ * still intercepts.
+ */
+export declare function processEmitWarning(...args: Parameters<NodeJS.Process['emitWarning']>): void;
+/**
+ * The process environment object. Returns the live `process.env` off the
+ * captured process (call-through, so a test that swaps `process.env` is seen).
+ *
+ * @example
+ *   ;```typescript
+ *   const token = processEnv()['SOCKET_API_TOKEN']
+ *   ```
+ */
+export declare function processEnv(): NodeJS.ProcessEnv;
+/**
+ * The absolute path to the Node executable (`process.execPath`).
+ */
+export declare function processExecPath(): string;
+/**
+ * Schedule a callback on the next tick. Call-through (late-bound).
+ */
+export declare function processNextTick(...args: Parameters<NodeJS.Process['nextTick']>): void;
+/**
+ * The process id.
+ */
+export declare function processPid(): number;
+/**
+ * The OS platform token (`'darwin'` / `'linux'` / `'win32'` / …).
+ *
+ * @example
+ *   ;```typescript
+ *   if (processPlatform() === 'win32') { … }
+ *   ```
+ */
+export declare function processPlatform(): NodeJS.Platform;
+/**
+ * The standard error stream. Returned off the captured process so a test that
+ * spies on `process.stderr.write` still intercepts.
+ */
+export declare function processStderr(): NodeJS.WriteStream;
+/**
+ * The standard output stream. Returned off the captured process so a test that
+ * spies on `process.stdout.write` still intercepts.
+ */
+export declare function processStdout(): NodeJS.WriteStream;
+/**
+ * The Node version string (`process.version`, e.g. `'v26.2.0'`).
+ */
+export declare function processVersion(): string;

package/dist/primordials/process.js

@@ -0,0 +1,132 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/primordials/process.ts
+/**
+* @file Safe call-through accessors for the `process` global's methods and
+*   value reads. The `process` object reference is captured once at module load
+*   (immune to a later `globalThis.process = …` reassignment), but each method
+*   is CALLED at access time off that captured object — so `vi.spyOn(process,
+*   'cwd')`, which mutates the same captured object, still intercepts. Binding
+*   the method reference instead (`process.cwd.bind(process)`) would freeze it
+*   and break that test seam, so we deliberately keep the late call. Consumers
+*   read cwd / platform / env / argv through these instead of touching
+*   `process` directly; enforced fleet-wide by
+*   `socket/prefer-process-primordial`. This is the `process` leaf of the
+*   node-module primordials: where `node/fs` / `node/path` lazy-load a `node:`
+*   module behind a function, this captures the always-present `process` global
+*   and routes its hot reads through one tamper-resistant surface.
+*/
+const SafeProcess = process;
+/**
+* The CPU architecture token (`'x64'` / `'arm64'` / …).
+*/
+function processArch() {
+	return SafeProcess.arch;
+}
+/**
+* The argv array (`[execPath, scriptPath, ...args]`).
+*
+* @example
+*   ;```typescript
+*   const entry = processArgv()[1]
+*   ```
+*/
+function processArgv() {
+	return SafeProcess.argv;
+}
+/**
+* The current working directory. Call-through to the captured process's `cwd` —
+* late-bound so test spies still intercept.
+*
+* @example
+*   ;```typescript
+*   const dir = processCwd()
+*   ```
+*/
+function processCwd() {
+	return SafeProcess.cwd();
+}
+/**
+* Emit a process warning. Call-through so a test spy on `process.emitWarning`
+* still intercepts.
+*/
+function processEmitWarning(...args) {
+	SafeProcess.emitWarning(...args);
+}
+/**
+* The process environment object. Returns the live `process.env` off the
+* captured process (call-through, so a test that swaps `process.env` is seen).
+*
+* @example
+*   ;```typescript
+*   const token = processEnv()['SOCKET_API_TOKEN']
+*   ```
+*/
+function processEnv() {
+	return SafeProcess.env;
+}
+/**
+* The absolute path to the Node executable (`process.execPath`).
+*/
+function processExecPath() {
+	return SafeProcess.execPath;
+}
+/**
+* Schedule a callback on the next tick. Call-through (late-bound).
+*/
+function processNextTick(...args) {
+	SafeProcess.nextTick(...args);
+}
+/**
+* The process id.
+*/
+function processPid() {
+	return SafeProcess.pid;
+}
+/**
+* The OS platform token (`'darwin'` / `'linux'` / `'win32'` / …).
+*
+* @example
+*   ;```typescript
+*   if (processPlatform() === 'win32') { … }
+*   ```
+*/
+function processPlatform() {
+	return SafeProcess.platform;
+}
+/**
+* The standard error stream. Returned off the captured process so a test that
+* spies on `process.stderr.write` still intercepts.
+*/
+function processStderr() {
+	return SafeProcess.stderr;
+}
+/**
+* The standard output stream. Returned off the captured process so a test that
+* spies on `process.stdout.write` still intercepts.
+*/
+function processStdout() {
+	return SafeProcess.stdout;
+}
+/**
+* The Node version string (`process.version`, e.g. `'v26.2.0'`).
+*/
+function processVersion() {
+	return SafeProcess.version;
+}
+
+//#endregion
+exports.processArch = processArch;
+exports.processArgv = processArgv;
+exports.processCwd = processCwd;
+exports.processEmitWarning = processEmitWarning;
+exports.processEnv = processEnv;
+exports.processExecPath = processExecPath;
+exports.processNextTick = processNextTick;
+exports.processPid = processPid;
+exports.processPlatform = processPlatform;
+exports.processStderr = processStderr;
+exports.processStdout = processStdout;
+exports.processVersion = processVersion;

package/dist/primordials/string.d.ts

@@ -50,8 +50,8 @@ export declare const StringPrototypeNormalize: (self: unknown, form?: string | u
 export declare const StringPrototypePadEnd: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
 export declare const StringPrototypePadStart: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
 export declare const StringPrototypeRepeat: (self: unknown, count: number) => string;
-export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
-export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
+export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: unknown[]) => string)) => string;
+export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: unknown[]) => string)) => string;
 export declare const StringPrototypeSearch: (self: unknown, searcher: {
     [Symbol.search](string: string): number;
 }) => number;

package/dist/primordials/string.js

@@ -34,17 +34,17 @@ const require_smol_primordial = require('../smol/primordial.js');
 *   `src/socketsecurity/primordial/primordial_binding.cc:41-72` for the
 *   canonical design statement.
 */
-const _smolPrimordial = /* @__PURE__ */ require_smol_primordial.getSmolPrimordial();
+const smolPrimordial = require_smol_primordial.getSmolPrimordial();
 const StringCtor = String;
 const StringFromCharCode = String.fromCharCode;
 const StringFromCodePoint = String.fromCodePoint;
 const StringRaw = String.raw;
 const StringPrototypeAt = require_primordials_uncurry.uncurryThis(String.prototype.at);
 const StringPrototypeCharAt = require_primordials_uncurry.uncurryThis(String.prototype.charAt);
-const _smolCharCodeAt = _smolPrimordial?.stringCharCodeAt;
-/* c8 ignore start */
-const StringPrototypeCharCodeAt = _smolCharCodeAt ? (s, i) => {
-	const code = _smolCharCodeAt(s, i);
+const smolCharCodeAt = smolPrimordial?.stringCharCodeAt;
+/* c8 ignore start - smol Node fast path unreachable on stock Node test runner */
+const StringPrototypeCharCodeAt = smolCharCodeAt ? (s, i) => {
+	const code = smolCharCodeAt(s, i);
 	return code === -1 ? NaN : code;
 } : require_primordials_uncurry.uncurryThis(String.prototype.charCodeAt);
 /* c8 ignore stop */
@@ -53,7 +53,7 @@ const StringPrototypeConcat = require_primordials_uncurry.uncurryThis(String.pro
 const StringPrototypeEndsWith = require_primordials_uncurry.uncurryThis(String.prototype.endsWith);
 const StringPrototypeIncludes = require_primordials_uncurry.uncurryThis(String.prototype.includes);
 const StringPrototypeIndexOf = require_primordials_uncurry.uncurryThis(String.prototype.indexOf);
-const StringPrototypeIsWellFormed = _smolPrimordial?.stringIsWellFormed ?? require_primordials_uncurry.uncurryThis(String.prototype.isWellFormed);
+const StringPrototypeIsWellFormed = smolPrimordial?.stringIsWellFormed ?? require_primordials_uncurry.uncurryThis(String.prototype.isWellFormed);
 const StringPrototypeLastIndexOf = require_primordials_uncurry.uncurryThis(String.prototype.lastIndexOf);
 const StringPrototypeLocaleCompare = require_primordials_uncurry.uncurryThis(String.prototype.localeCompare);
 const StringPrototypeMatch = require_primordials_uncurry.uncurryThis(String.prototype.match);

package/dist/primordials/symbol.js

@@ -29,10 +29,10 @@ const SymbolSplit = Symbol.split;
 const SymbolToPrimitive = Symbol.toPrimitive;
 const SymbolToStringTag = Symbol.toStringTag;
 const SymbolUnscopables = Symbol.unscopables;
-const _symbolDescriptionGetter = Symbol.prototype.__lookupGetter__("description");
+const symbolDescriptionGetter = Symbol.prototype.__lookupGetter__("description");
 function SymbolPrototypeDescription(self) {
-	/* c8 ignore start */
-	return _symbolDescriptionGetter ? _symbolDescriptionGetter.call(self) : self.description;
+	/* c8 ignore start - description getter is always present in modern V8; the fallback branch is unreachable */
+	return symbolDescriptionGetter ? symbolDescriptionGetter.call(self) : self.description;
 	/* c8 ignore stop */
 }
 const SymbolPrototypeToString = require_primordials_uncurry.uncurryThis(Symbol.prototype.toString);

package/dist/primordials/uncurry.d.ts

@@ -12,7 +12,6 @@
 export declare const uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
 export declare const applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
 export declare const applySafe: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R | undefined;
-type BindCall = <T, P extends readonly unknown[], A extends readonly unknown[], R>(fn: (this: T, ...args: [...P, ...A]) => R, thisArg: T, ...presetArgs: P) => (...newArgs: A) => R;
+export type BindCall = <T, P extends readonly unknown[], A extends readonly unknown[], R>(fn: (this: T, ...args: [...P, ...A]) => R, thisArg: T, ...presetArgs: P) => (...newArgs: A) => R;
 export declare const bindCall: BindCall;
 export declare const weakRefSafe: <T extends object | symbol>(target: T) => WeakRef<T> | undefined;
-export {};

package/dist/primordials/uncurry.js

@@ -15,13 +15,13 @@ const require_smol_detect = require('../smol/detect.js');
 *   or `Reflect` here. tsgo has a bug that mis-transpiles destructured exports.
 *   See: https://github.com/SocketDev/socket-packageurl-js/issues/3.
 */
-const _smolUtil = /* @__PURE__ */ require_smol_detect.getSmolUtil();
+const smolUtil = require_smol_detect.getSmolUtil();
 const { apply, bind, call } = Function.prototype;
-const uncurryThis = _smolUtil?.uncurryThis ?? bind.bind(call);
-const applyBind = _smolUtil?.applyBind ?? bind.bind(apply);
-const _applyBoundForSafe = applyBind;
-const applySafe = _smolUtil?.applySafe ?? ((fn) => {
-	const apply2 = _applyBoundForSafe(fn);
+const uncurryThis = smolUtil?.uncurryThis ?? bind.bind(call);
+const applyBind = smolUtil?.applyBind ?? bind.bind(apply);
+const applyBoundForSafe = applyBind;
+const applySafe = smolUtil?.applySafe ?? ((fn) => {
+	const apply2 = applyBoundForSafe(fn);
 	return (self, args) => {
 		try {
 			return apply2(self, args);
@@ -30,9 +30,9 @@ const applySafe = _smolUtil?.applySafe ?? ((fn) => {
 		}
 	};
 });
-const _bindCallFallback = ((fn, thisArg, ...presetArgs) => Function.prototype.bind.apply(fn, [thisArg, ...presetArgs]));
-const bindCall = _smolUtil?.bindCall ?? _bindCallFallback;
-const weakRefSafe = _smolUtil?.weakRefSafe ?? ((target) => {
+const bindCallFallback = ((fn, thisArg, ...presetArgs) => Function.prototype.bind.apply(fn, [thisArg, ...presetArgs]));
+const bindCall = smolUtil?.bindCall ?? bindCallFallback;
+const weakRefSafe = smolUtil?.weakRefSafe ?? ((target) => {
 	try {
 		return new WeakRef(target);
 	} catch {

package/dist/process/abort.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   `AbortController` and its `AbortSignal` so cooperating modules can
 *   coordinate cancellation from a single source.
 */
-let _abortController;
+let abortController;
 /**
 * Get the process-scoped shared `AbortController` singleton. Cooperating
 * modules use this to coordinate cancellation across the library.
@@ -16,8 +16,8 @@ let _abortController;
 * @returns The lazily-created shared `AbortController` instance.
 */
 function getAbortController() {
-	if (_abortController === void 0) _abortController = new AbortController();
-	return _abortController;
+	if (abortController === void 0) abortController = new AbortController();
+	return abortController;
 }
 /**
 * Get the process-scoped shared `AbortSignal` singleton. This is the `signal`

package/dist/process/lock-manager.js

@@ -72,12 +72,12 @@ var ProcessLockManager = class {
 	*/
 	ensureExitHandler() {
 		if (this.exitHandlerRegistered) return;
-		/* @__PURE__ */ require_events_exit_handler.onExit(() => {
+		require_events_exit_handler.onExit(() => {
 			/* c8 ignore start - Exit-handler body only fires on real
 			process exit. Subprocess test infra would be needed. */
 			for (const timer of this.touchTimers.values()) clearInterval(timer);
 			this.touchTimers.clear();
-			const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+			const fs = require_node_fs.getNodeFs();
 			for (const lockPath of this.activeLocks) try {
 				if (fs.existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 			} catch {}
@@ -93,7 +93,7 @@ var ProcessLockManager = class {
 	*/
 	touchLock(lockPath) {
 		try {
-			const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+			const fs = require_node_fs.getNodeFs();
 			if (fs.existsSync(lockPath)) {
 				const now = require_primordials_date.DateNow() / 1e3;
 				fs.utimesSync(lockPath, now, now);
@@ -142,7 +142,7 @@ var ProcessLockManager = class {
 	*/
 	isStale(lockPath, staleMs) {
 		try {
-			const stats = (/* @__PURE__ */ require_node_fs.getNodeFs()).statSync(lockPath, { throwIfNoEntry: false });
+			const stats = require_node_fs.getNodeFs().statSync(lockPath, { throwIfNoEntry: false });
 			if (!stats) return false;
 			return require_primordials_date.DateNow() - stats.mtime.getTime() > staleMs;
 		} catch {
@@ -178,7 +178,7 @@ var ProcessLockManager = class {
 	async acquire(lockPath, options = {}) {
 		const { baseDelayMs = 100, maxDelayMs = 1e3, retries = 3, staleMs = 5e3, touchIntervalMs = 2e3 } = options;
 		this.ensureExitHandler();
-		return await /* @__PURE__ */ require_promises_retry.pRetry(async () => {
+		return await require_promises_retry.pRetry(async () => {
 			try {
 				if (this.isStale(lockPath, staleMs)) {
 					logger.log(`Removing stale lock: ${lockPath}`);
@@ -186,8 +186,8 @@ var ProcessLockManager = class {
 						require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 					} catch {}
 				}
-				const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-				const parent = (/* @__PURE__ */ require_node_path.getNodePath()).dirname(lockPath);
+				const fs = require_node_fs.getNodeFs();
+				const parent = require_node_path.getNodePath().dirname(lockPath);
 				if (parent && parent !== "." && parent !== lockPath) fs.mkdirSync(parent, { recursive: true });
 				fs.mkdirSync(lockPath);
 				this.activeLocks.add(lockPath);
@@ -238,7 +238,7 @@ Parent path: ${parentDir}\nTo resolve:
 	release(lockPath) {
 		this.stopTouchTimer(lockPath);
 		try {
-			if ((/* @__PURE__ */ require_node_fs.getNodeFs()).existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
+			if (require_node_fs.getNodeFs().existsSync(lockPath)) require_fs_safe.safeDeleteSync(lockPath, { recursive: true });
 			this.activeLocks.delete(lockPath);
 		} catch (e) {
 			logger.warn(`Failed to release lock ${lockPath}: ${require_errors_message.errorMessage(e)}`);

package/dist/process/spawn/_internal.js

@@ -13,17 +13,16 @@ const require_ansi_strip = require('../../ansi/strip.js');
 */
 const stackCache = new require_primordials_map_set.WeakMapCtor();
 const spawnBinPathCache = new require_primordials_map_set.MapCtor();
-const windowsScriptExtRegExp = /\.(?:cmd|bat|ps1)$/i;
-let _npmCliPromiseSpawn;
+const windowsScriptExtRegExp = /\.(?:bat|cmd|ps1)$/i;
+let npmCliPromiseSpawnCache;
 /**
 * Lazily load the `@npmcli/promise-spawn` module to avoid Webpack bundling
 * issues. Required because the upstream module uses CJS dynamic-require
 * patterns that Webpack flags.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getNpmCliPromiseSpawn() {
-	if (_npmCliPromiseSpawn === void 0) _npmCliPromiseSpawn = /*@__PURE__*/ require("../../external/@npmcli/promise-spawn");
-	return _npmCliPromiseSpawn;
+	if (npmCliPromiseSpawnCache === void 0) npmCliPromiseSpawnCache = /*@__PURE__*/ require("../../external/@npmcli/promise-spawn");
+	return npmCliPromiseSpawnCache;
 }
 /**
 * Strip ANSI escape codes from spawn result stdout and stderr. Modifies the
@@ -33,12 +32,11 @@ function getNpmCliPromiseSpawn() {
 *
 * @returns {unknown} The modified result object
 */
-/*@__NO_SIDE_EFFECTS__*/
 function stripAnsiFromSpawnResult(result) {
 	const res = result;
 	const { stderr, stdout } = res;
-	if (typeof stdout === "string") res.stdout = /* @__PURE__ */ require_ansi_strip.stripAnsi(stdout);
-	if (typeof stderr === "string") res.stderr = /* @__PURE__ */ require_ansi_strip.stripAnsi(stderr);
+	if (typeof stdout === "string") res.stdout = require_ansi_strip.stripAnsi(stdout);
+	if (typeof stderr === "string") res.stderr = require_ansi_strip.stripAnsi(stderr);
 	return res;
 }