@socketsecurity/lib 5.26.1 → 5.27.0

package/dist/smol/primordial.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Lazy-loader for socket-btm's `node:smol-primordial`
+ * binding.
+ *
+ * `node:smol-primordial` provides V8 Fast API typed implementations
+ * of Math.* and Number.is* primordials, registered with
+ * `CFunction::Make()` so TurboFan inlines them directly into JIT-
+ * compiled JS callers. Bypasses the FunctionCallbackInfo trampoline
+ * entirely — ~30-50% gain on hot loops where V8 doesn't already
+ * auto-inline.
+ *
+ * Returns `undefined` on stock Node + non-Node runtimes. Result is
+ * cached across calls.
+ *
+ * @internal — used by `src/primordials.ts` to resolve smol-aware
+ *   Math.* / Number.is* fast paths. Most callers should use the
+ *   standard `primordials` exports, which already route through this
+ *   when smol is present.
+ *
+ * @see https://v8.dev/blog/v8-release-99 — V8 Fast API Calls overview
+ */
+/**
+ * Surface of `node:smol-primordial`. See socket-btm's
+ * additions/source-patched/lib/smol-primordial.js for the canonical
+ * shape.
+ *
+ * Each entry is registered as a `v8::CFunction` so V8 can inline the
+ * C++ implementation directly into JIT-compiled callers — eliminating
+ * the FunctionCallbackInfo allocation, the HandleScope, and the call-
+ * site trampoline. See the C++ binding file for which signatures
+ * get real wins (and which don't).
+ */
+export interface SmolPrimordialBinding {
+    arrayIsArray(v: unknown): v is unknown[];
+    dateNow(): number;
+    mathAbs(x: number): number;
+    mathAcos(x: number): number;
+    mathAcosh(x: number): number;
+    mathAsin(x: number): number;
+    mathAsinh(x: number): number;
+    mathAtan(x: number): number;
+    mathAtan2(a: number, b: number): number;
+    mathAtanh(x: number): number;
+    mathCbrt(x: number): number;
+    mathCeil(x: number): number;
+    mathClz32(v: number): number;
+    mathCos(x: number): number;
+    mathCosh(x: number): number;
+    mathExp(x: number): number;
+    mathExpm1(x: number): number;
+    mathFloor(x: number): number;
+    mathFround(x: number): number;
+    mathHypot(a: number, b: number): number;
+    mathImul(a: number, b: number): number;
+    mathLog(x: number): number;
+    mathLog1p(x: number): number;
+    mathLog2(x: number): number;
+    mathLog10(x: number): number;
+    mathPow(a: number, b: number): number;
+    mathRound(x: number): number;
+    mathSign(x: number): number;
+    mathSin(x: number): number;
+    mathSinh(x: number): number;
+    mathSqrt(x: number): number;
+    mathTan(x: number): number;
+    mathTanh(x: number): number;
+    mathTrunc(x: number): number;
+    numberIsFinite(v: unknown): boolean;
+    numberIsInteger(v: unknown): boolean;
+    numberIsNaN(v: unknown): boolean;
+    numberIsSafeInteger(v: unknown): boolean;
+    numberParseFloat(s: string): number;
+    numberParseInt10(s: string): number;
+    stringCharCodeAt(s: string, i: number): number;
+}
+/**
+ * Returns `node:smol-primordial` when running on the smol Node
+ * binary, otherwise `undefined`. Result is cached across calls.
+ */
+export declare function getSmolPrimordial(): SmolPrimordialBinding | undefined;

package/dist/smol/primordial.js

@@ -0,0 +1,46 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var primordial_exports = {};
+__export(primordial_exports, {
+  getSmolPrimordial: () => getSmolPrimordial
+});
+module.exports = __toCommonJS(primordial_exports);
+var import_util = require("./util");
+let _smolPrimordial;
+// @__NO_SIDE_EFFECTS__
+function getSmolPrimordial() {
+  if (_smolPrimordial === void 0) {
+    if ((0, import_util.isSmol)()) {
+      try {
+        _smolPrimordial = require("node:smol-primordial");
+      } catch {
+        _smolPrimordial = null;
+      }
+    } else {
+      _smolPrimordial = null;
+    }
+  }
+  return _smolPrimordial ?? void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSmolPrimordial
+});

package/dist/smol/util.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Smol detection + lazy-loader for `node:smol-util`.
+ *
+ * Two responsibilities:
+ *
+ *   1. `isSmol()` — memoized boolean detector for socket-btm's smol
+ *      Node binary. Mirrors `isSeaBinary()` from `src/sea.ts`. Probes
+ *      via `node:module.isBuiltin('node:smol-util')` since only the
+ *      smol binary registers any `node:smol-*` builtins.
+ *
+ *   2. `getSmolUtil()` — lazy-loader for the `node:smol-util` binding,
+ *      which provides native `uncurryThis` and `applyBind` (single
+ *      V8 dispatch via `args.Data()` + `v8::Function::Call`, skipping
+ *      the BoundFunction adapter + `Function.prototype.call` trampoline
+ *      that the JS form `bind.bind(call)(fn)` hits twice per invocation).
+ *      ~2x faster on hot uncurried-call sites.
+ *
+ * `getSmolUtil()` returns `undefined` on stock Node + non-Node
+ * runtimes. Result is cached across calls; the lazy-loader follows
+ * the same shape as `src/node/fs.ts` etc.
+ *
+ * @see https://github.com/SocketDev/socket-btm — socket-btm builds
+ *   the smol binary that exposes the `node:smol-util` binding.
+ */
+/**
+ * Detect if the current process is running on socket-btm's smol Node
+ * binary. Memoized on first call.
+ *
+ * Defensive across runtimes: returns `false` on stock Node, browsers
+ * (no `node:module`), Deno / Bun (different module resolution), and
+ * worker threads (each has its own builtin table).
+ *
+ * @example
+ * ```ts
+ * import { isSmol } from '@socketsecurity/lib/smol/util'
+ *
+ * if (isSmol()) {
+ *   // running on the smol binary; native fast paths available
+ * }
+ * ```
+ */
+export declare function isSmol(): boolean;
+/**
+ * Surface of `node:smol-util`. See socket-btm's
+ * additions/source-patched/lib/smol-util.js for the canonical shape.
+ */
+export interface SmolUtilBinding {
+    /**
+     * Native equivalent of `Function.prototype.bind.bind(apply)(fn)`.
+     */
+    applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
+    /**
+     * Native equivalent of:
+     *   `(self, args) => { try { return fn.apply(self, args) } catch {} }`.
+     * Returns a function that swallows synchronous throws and returns
+     * `undefined`. Avoids JS-level throw construction on the swallow
+     * path — useful for logger sinks, debug hooks, abort handlers, etc.
+     */
+    applySafe: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R | undefined;
+    /**
+     * Native equivalent of:
+     *   `(...newArgs) => fn.call(thisArg, ...presetArgs, ...newArgs)`.
+     * Same shape as `Function.prototype.bind` but with a single C++
+     * dispatch instead of going through V8's BoundFunction adapter.
+     * Useful where `bind` would be hot — captured callbacks fed to
+     * `setImmediate`/`setTimeout`/promise continuations.
+     */
+    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;
+    /**
+     * Native equivalent of `Function.prototype.bind.bind(call)(fn)`.
+     * Single C++ dispatch via `args.Data()` + `v8::Function::Call`.
+     */
+    uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
+    /**
+     * Native equivalent of:
+     *   `try { return new WeakRef(target) } catch { return undefined }`.
+     * Returns `undefined` for non-Object, non-Symbol inputs that would
+     * make the constructor throw. The Safe suffix follows the project's
+     * non-throwing-wrapper convention.
+     */
+    weakRefSafe: <T extends object | symbol>(target: T) => WeakRef<T> | undefined;
+}
+/**
+ * Returns `node:smol-util` when running on the smol Node binary,
+ * otherwise `undefined`. Result is cached across calls.
+ */
+export declare function getSmolUtil(): SmolUtilBinding | undefined;

package/dist/smol/util.js

@@ -0,0 +1,59 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  getSmolUtil: () => getSmolUtil,
+  isSmol: () => isSmol
+});
+module.exports = __toCommonJS(util_exports);
+let _isSmol;
+function isSmol() {
+  if (_isSmol === void 0) {
+    try {
+      const mod = require("node:module");
+      _isSmol = typeof mod.isBuiltin === "function" && mod.isBuiltin("node:smol-util");
+    } catch {
+      _isSmol = false;
+    }
+  }
+  return _isSmol ?? false;
+}
+let _smolUtil;
+// @__NO_SIDE_EFFECTS__
+function getSmolUtil() {
+  if (_smolUtil === void 0) {
+    if (isSmol()) {
+      try {
+        _smolUtil = require("node:smol-util");
+      } catch {
+        _smolUtil = null;
+      }
+    } else {
+      _smolUtil = null;
+    }
+  }
+  return _smolUtil ?? void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSmolUtil,
+  isSmol
+});

package/dist/smol/versions.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Lazy-loader for socket-btm's `node:smol-versions`.
+ *
+ * `node:smol-versions` is the multi-ecosystem version helper exposed
+ * by socket-btm's smol Node binary. It supports npm/maven/pypi/nuget/
+ * gem version comparison + range satisfies with internal C++
+ * acceleration on the npm hot path.
+ *
+ * Returns `undefined` on stock Node + non-Node runtimes. Result is
+ * cached across calls.
+ *
+ * @internal — used by `src/versions.ts` to resolve smol-aware version
+ *   ops. Most callers should use the standard `versions` exports,
+ *   which already route through this when smol is present.
+ */
+/**
+ * Surface of `node:smol-versions`. See socket-btm's
+ * additions/source-patched/lib/smol-versions.js for the canonical
+ * shape. Each entry takes an optional `ecosystem` (default `'npm'`)
+ * — pass it for non-npm versions; npm callers can omit.
+ */
+export interface SmolVersionsBinding {
+    compare(a: string, b: string, ecosystem?: string): -1 | 0 | 1;
+    eq(a: string, b: string, ecosystem?: string): boolean;
+    gt(a: string, b: string, ecosystem?: string): boolean;
+    gte(a: string, b: string, ecosystem?: string): boolean;
+    inc(version: string, release: 'major' | 'minor' | 'patch' | 'prerelease', ecosystem?: string, identifier?: string): string | undefined;
+    lt(a: string, b: string, ecosystem?: string): boolean;
+    lte(a: string, b: string, ecosystem?: string): boolean;
+    max(versions: readonly string[], ecosystem?: string): string | undefined;
+    maxSatisfying(versions: readonly string[], range: string, ecosystem?: string): string | undefined;
+    min(versions: readonly string[], ecosystem?: string): string | undefined;
+    minSatisfying(versions: readonly string[], range: string, ecosystem?: string): string | undefined;
+    neq(a: string, b: string, ecosystem?: string): boolean;
+    rsort(versions: readonly string[], ecosystem?: string): string[];
+    satisfies(version: string, range: string, ecosystem?: string): boolean;
+    sort(versions: readonly string[], ecosystem?: string): string[];
+    valid(version: string, ecosystem?: string): string | undefined;
+    filter(versions: readonly string[], range: string, ecosystem?: string): string[];
+    coerce(version: string, ecosystem?: string): string | undefined;
+}
+/**
+ * Returns `node:smol-versions` when running on the smol Node binary,
+ * otherwise `undefined`. Result is cached across calls.
+ */
+export declare function getSmolVersions(): SmolVersionsBinding | undefined;

package/dist/smol/versions.js

@@ -0,0 +1,46 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var versions_exports = {};
+__export(versions_exports, {
+  getSmolVersions: () => getSmolVersions
+});
+module.exports = __toCommonJS(versions_exports);
+var import_util = require("./util");
+let _smolVersions;
+// @__NO_SIDE_EFFECTS__
+function getSmolVersions() {
+  if (_smolVersions === void 0) {
+    if ((0, import_util.isSmol)()) {
+      try {
+        _smolVersions = require("node:smol-versions");
+      } catch {
+        _smolVersions = null;
+      }
+    } else {
+      _smolVersions = null;
+    }
+  }
+  return _smolVersions ?? void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSmolVersions
+});

package/dist/spawn.js

@@ -42,6 +42,9 @@ var import_arrays = require("./arrays");
 var import_bin = require("./bin");
 var import_process = require("./constants/process");
 var import_errors = require("./errors");
+var import_child_process = require("./node/child-process");
+var import_fs = require("./node/fs");
+var import_path = require("./node/path");
 var import_objects = require("./objects");
 var import_normalize = require("./paths/normalize");
 var import_spinner = require("./spinner");
@@ -53,23 +56,6 @@ const stackCache = new import_primordials.WeakMapCtor();
 const spawnBinPathCache = new import_primordials.MapCtor();
 const windowsScriptExtRegExp = /\.(?:cmd|bat|ps1)$/i;
 let _npmCliPromiseSpawn;
-let _path;
-let _fs;
-let _child_process;
-// @__NO_SIDE_EFFECTS__
-function getChildProcess() {
-  if (_child_process === void 0) {
-    _child_process = require("node:child_process");
-  }
-  return _child_process;
-}
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
 // @__NO_SIDE_EFFECTS__
 function getNpmCliPromiseSpawn() {
   if (_npmCliPromiseSpawn === void 0) {
@@ -78,13 +64,6 @@ function getNpmCliPromiseSpawn() {
   return _npmCliPromiseSpawn;
 }
 // @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-// @__NO_SIDE_EFFECTS__
 function stripAnsiFromSpawnResult(result) {
   const res = result;
   const { stderr, stdout } = res;
@@ -197,7 +176,7 @@ function spawn(cmd, args, options, extra) {
   const cwd = spawnOptions.cwd ? String(spawnOptions.cwd) : void 0;
   let actualCmd = cmd;
   if (!(0, import_normalize.isPath)(cmd)) {
-    const fs = /* @__PURE__ */ getFs();
+    const fs = (0, import_fs.getNodeFs)();
     const cached = spawnBinPathCache.get(cmd);
     if (cached) {
       if (fs.existsSync(cached)) {
@@ -217,7 +196,10 @@ function spawn(cmd, args, options, extra) {
   const WIN32 = import_node_process.default.platform === "win32";
   if (WIN32 && shell && (0, import_primordials.RegExpPrototypeTest)(windowsScriptExtRegExp, actualCmd)) {
     if (!(0, import_normalize.isPath)(actualCmd)) {
-      actualCmd = (/* @__PURE__ */ getPath()).basename(actualCmd, (/* @__PURE__ */ getPath()).extname(actualCmd));
+      actualCmd = (0, import_path.getNodePath)().basename(
+        actualCmd,
+        (0, import_path.getNodePath)().extname(actualCmd)
+      );
     }
   }
   const wasSpinning = !!spinnerInstance?.isSpinning;
@@ -313,7 +295,10 @@ function spawnSync(cmd, args, options) {
   const WIN32 = import_node_process.default.platform === "win32";
   if (WIN32 && shell && (0, import_primordials.RegExpPrototypeTest)(windowsScriptExtRegExp, actualCmd)) {
     if (!(0, import_normalize.isPath)(actualCmd)) {
-      actualCmd = (/* @__PURE__ */ getPath()).basename(actualCmd, (/* @__PURE__ */ getPath()).extname(actualCmd));
+      actualCmd = (0, import_path.getNodePath)().basename(
+        actualCmd,
+        (0, import_path.getNodePath)().extname(actualCmd)
+      );
     }
   }
   const { stripAnsi: shouldStripAnsi = true, ...rawSpawnOptions } = {
@@ -327,7 +312,7 @@ function spawnSync(cmd, args, options) {
     ...rawSpawnOptions
   };
   const stdioString = spawnOptions.encoding !== "buffer";
-  const result = (/* @__PURE__ */ getChildProcess()).spawnSync(actualCmd, args, spawnOptions);
+  const result = (0, import_child_process.getNodeChildProcess)().spawnSync(actualCmd, args, spawnOptions);
   if (stdioString) {
     const { stderr, stdout } = result;
     if (stdout) {

package/dist/versions.js

@@ -42,6 +42,8 @@ __export(versions_exports, {
   versionDiff: () => versionDiff
 });
 module.exports = __toCommonJS(versions_exports);
+var import_versions = require("./smol/versions");
+const _smolVersions = (0, import_versions.getSmolVersions)();
 let _semver;
 function getSemver() {
   if (_semver === void 0) {
@@ -49,6 +51,9 @@ function getSemver() {
   }
   return _semver;
 }
+function getVersionsImpl() {
+  return _smolVersions ?? getSemver();
+}
 function coerceVersion(version) {
   const semver = getSemver();
   const coerced = semver.coerce(version);
@@ -56,15 +61,15 @@ function coerceVersion(version) {
 }
 function compareVersions(v1, v2) {
   try {
-    const semver = getSemver();
-    return semver.compare(v1, v2);
+    const impl = getVersionsImpl();
+    return impl.compare(v1, v2);
   } catch {
     return void 0;
   }
 }
 function filterVersions(versions, range) {
-  const semver = getSemver();
-  return versions.filter((v) => semver.satisfies(v, range));
+  const impl = getVersionsImpl();
+  return versions.filter((v) => impl.satisfies(v, range));
 }
 function getMajorVersion(version) {
   const semver = getSemver();
@@ -86,28 +91,28 @@ function incrementVersion(version, release, identifier) {
   return semver.inc(version, release, identifier) || void 0;
 }
 function isEqual(version1, version2) {
-  const semver = getSemver();
-  return semver.eq(version1, version2);
+  const impl = getVersionsImpl();
+  return impl.eq(version1, version2);
 }
 function isGreaterThan(version1, version2) {
-  const semver = getSemver();
-  return semver.gt(version1, version2);
+  const impl = getVersionsImpl();
+  return impl.gt(version1, version2);
 }
 function isGreaterThanOrEqual(version1, version2) {
-  const semver = getSemver();
-  return semver.gte(version1, version2);
+  const impl = getVersionsImpl();
+  return impl.gte(version1, version2);
 }
 function isLessThan(version1, version2) {
-  const semver = getSemver();
-  return semver.lt(version1, version2);
+  const impl = getVersionsImpl();
+  return impl.lt(version1, version2);
 }
 function isLessThanOrEqual(version1, version2) {
-  const semver = getSemver();
-  return semver.lte(version1, version2);
+  const impl = getVersionsImpl();
+  return impl.lte(version1, version2);
 }
 function isValidVersion(version) {
-  const semver = getSemver();
-  return semver.valid(version) !== null;
+  const impl = getVersionsImpl();
+  return impl.valid(version) != null;
 }
 function maxVersion(versions) {
   const semver = getSemver();
@@ -132,16 +137,16 @@ function parseVersion(version) {
   };
 }
 function satisfiesVersion(version, range) {
-  const semver = getSemver();
-  return semver.satisfies(version, range);
+  const impl = getVersionsImpl();
+  return impl.satisfies(version, range);
 }
 function sortVersions(versions) {
-  const semver = getSemver();
-  return semver.sort([...versions]);
+  const impl = getVersionsImpl();
+  return impl.sort([...versions]);
 }
 function sortVersionsDesc(versions) {
-  const semver = getSemver();
-  return semver.rsort([...versions]);
+  const impl = getVersionsImpl();
+  return impl.rsort([...versions]);
 }
 function versionDiff(version1, version2) {
   try {