@socketsecurity/lib 5.26.0 → 5.27.0

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,33 +42,20 @@ 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");
 var import_strings = require("./strings");
+var import_primordials = require("./primordials");
 const abortSignal = (0, import_process.getAbortSignal)();
 const spinner = (0, import_spinner.getDefaultSpinner)();
-const stackCache = /* @__PURE__ */ new WeakMap();
-const spawnBinPathCache = /* @__PURE__ */ new Map();
+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) {
@@ -77,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;
@@ -133,7 +113,7 @@ ${firstLine.slice(0, 197)}...`;
   }
   const isSynthetic = err.message === "command failed";
   if (isSynthetic) {
-    Object.defineProperty(err, "message", {
+    (0, import_primordials.ObjectDefineProperty)(err, "message", {
       __proto__: null,
       value: enhancedMessage,
       writable: true,
@@ -142,14 +122,14 @@ ${firstLine.slice(0, 197)}...`;
     });
     return err;
   }
-  const enhancedError = new Error(enhancedMessage, {
+  const enhancedError = new import_primordials.ErrorCtor(enhancedMessage, {
     cause: err
   });
-  const descriptors = Object.getOwnPropertyDescriptors(err);
-  Reflect.deleteProperty(descriptors, "message");
-  Reflect.deleteProperty(descriptors, "stack");
-  Object.defineProperties(enhancedError, descriptors);
-  Object.defineProperty(enhancedError, "stack", {
+  const descriptors = (0, import_primordials.ObjectGetOwnPropertyDescriptors)(err);
+  (0, import_primordials.ReflectDeleteProperty)(descriptors, "message");
+  (0, import_primordials.ReflectDeleteProperty)(descriptors, "stack");
+  (0, import_primordials.ObjectDefineProperties)(enhancedError, descriptors);
+  (0, import_primordials.ObjectDefineProperty)(enhancedError, "stack", {
     __proto__: null,
     configurable: true,
     enumerable: false,
@@ -196,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)) {
@@ -214,9 +194,12 @@ function spawn(cmd, args, options, extra) {
     }
   }
   const WIN32 = import_node_process.default.platform === "win32";
-  if (WIN32 && shell && windowsScriptExtRegExp.test(actualCmd)) {
+  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;
@@ -253,35 +236,44 @@ function spawn(cmd, args, options, extra) {
   const oldSpawnPromise = spawnPromise;
   let newSpawnPromise;
   if (shouldStripAnsi && stdioString) {
-    newSpawnPromise = spawnPromise.then((result) => {
-      const strippedResult = /* @__PURE__ */ stripAnsiFromSpawnResult(result);
-      if ("code" in strippedResult) {
-        ;
-        strippedResult.exitCode = strippedResult.code;
+    newSpawnPromise = (async () => {
+      try {
+        const result = await spawnPromise;
+        const strippedResult = /* @__PURE__ */ stripAnsiFromSpawnResult(result);
+        if ("code" in strippedResult) {
+          ;
+          strippedResult.exitCode = strippedResult.code;
+        }
+        return strippedResult;
+      } catch (error) {
+        const strippedError = /* @__PURE__ */ stripAnsiFromSpawnResult(error);
+        throw /* @__PURE__ */ enhanceSpawnError(strippedError);
       }
-      return strippedResult;
-    }).catch((error) => {
-      const strippedError = /* @__PURE__ */ stripAnsiFromSpawnResult(error);
-      const enhancedError = /* @__PURE__ */ enhanceSpawnError(strippedError);
-      throw enhancedError;
-    });
+    })();
   } else {
-    newSpawnPromise = spawnPromise.then((result) => {
-      if (result !== null && typeof result === "object" && "code" in result) {
-        const res = result;
-        res.exitCode = res.code;
-        return res;
+    newSpawnPromise = (async () => {
+      try {
+        const result = await spawnPromise;
+        if (result !== null && typeof result === "object" && "code" in result) {
+          const res = result;
+          res.exitCode = res.code;
+          return res;
+        }
+        return result;
+      } catch (error) {
+        throw /* @__PURE__ */ enhanceSpawnError(error);
       }
-      return result;
-    }).catch((error) => {
-      const enhancedError = /* @__PURE__ */ enhanceSpawnError(error);
-      throw enhancedError;
-    });
+    })();
   }
   if (shouldRestartSpinner) {
-    newSpawnPromise = newSpawnPromise.finally(() => {
-      spinnerInstance.start();
-    });
+    const prevPromise = newSpawnPromise;
+    newSpawnPromise = (async () => {
+      try {
+        return await prevPromise;
+      } finally {
+        spinnerInstance.start();
+      }
+    })();
   }
   ;
   newSpawnPromise.process = oldSpawnPromise.process;
@@ -301,9 +293,12 @@ function spawnSync(cmd, args, options) {
   }
   const shell = (0, import_objects.getOwn)(options, "shell");
   const WIN32 = import_node_process.default.platform === "win32";
-  if (WIN32 && shell && windowsScriptExtRegExp.test(actualCmd)) {
+  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 } = {
@@ -317,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/spinner.d.ts

@@ -4,7 +4,7 @@
  */
 import type { Writable } from 'node:stream';
 import type { ColorInherit, ColorRgb, ColorValue } from './colors';
-import type { ShimmerColorGradient, ShimmerConfig, ShimmerDirection, ShimmerState } from './effects/text-shimmer';
+import type { Palette, ShimmerConfig, ShimmerDirection } from './effects/shimmer';
 /**
  * Symbol types for status messages.
  * Maps to log symbols: fail (✗), info (ℹ), skip (↻), success (✓), warn (⚠).
@@ -23,12 +23,19 @@ export type ProgressInfo = {
     unit?: string | undefined;
 };
 /**
- * Internal shimmer state with color configuration.
- * Extends `ShimmerState` with additional color property that can be inherited from spinner.
+ * Internal shimmer runtime state. Holds the user-facing config plus a
+ * monotonic frame counter; the spinner advances `frame` on each animation
+ * tick and feeds the current frame to the shimmer engine.
  */
-export type ShimmerInfo = ShimmerState & {
-    /** Color for shimmer effect - can inherit from spinner, use explicit color, or gradient */
-    color: ColorInherit | ColorValue | ShimmerColorGradient;
+export type ShimmerInfo = {
+    /** User-facing color reference (inherit, explicit value, or palette). */
+    color: ColorInherit | ColorValue | Palette;
+    /** Current direction (driven by config, snapshotted here for getters). */
+    direction: ShimmerDirection;
+    /** Steps per frame. */
+    speed: number;
+    /** Monotonic frame counter — advanced on each animation tick. */
+    frame: number;
 };
 /**
  * Spinner instance for displaying animated loading indicators.