@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/shell/parse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Tokenize a shell command line into typed entries (bare strings,
+ *   operators, comments, globs). Wraps the vendored `shell-quote`. Unlike
+ *   `argv/parse-args-string` (which flattens to a plain `string[]` for
+ *   `child_process.spawn`), this preserves shell structure — operator tokens
+ *   like `&&` / `|` / `;` surface as `{ op }`, comments as `{ comment }` — so a
+ *   caller can reason about command boundaries. `$VAR` references resolve
+ *   against `env`; unresolved ones collapse to an empty string.
+ */
+import type { ParseEntry } from '../external/shell-quote';
+export type { ParseEntry, ShellComment, ShellGlob, ShellOp, } from '../external/shell-quote';
+/**
+ * Tokenize `cmd` into `ParseEntry` items, preserving operators and comments.
+ * Throws on unterminated quotes.
+ *
+ * @example
+ *   parseShell('git commit -m "hello world"')
+ *   // → ['git', 'commit', '-m', 'hello world']
+ *
+ *   parseShell('ls && echo done')
+ *   // → ['ls', { op: '&&' }, 'echo', 'done']
+ *
+ *   parseShell('echo $HOME', { HOME: '/root' })
+ *   // → ['echo', '/root']
+ */
+export declare function parseShell(cmd: string, env?: Record<string, string> | ((key: string) => string | undefined) | undefined): ParseEntry[];

package/dist/shell/parse.js

@@ -0,0 +1,35 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let src_external_shell_quote = require("../external/shell-quote");
+
+//#region src/shell/parse.ts
+/**
+* @file Tokenize a shell command line into typed entries (bare strings,
+*   operators, comments, globs). Wraps the vendored `shell-quote`. Unlike
+*   `argv/parse-args-string` (which flattens to a plain `string[]` for
+*   `child_process.spawn`), this preserves shell structure — operator tokens
+*   like `&&` / `|` / `;` surface as `{ op }`, comments as `{ comment }` — so a
+*   caller can reason about command boundaries. `$VAR` references resolve
+*   against `env`; unresolved ones collapse to an empty string.
+*/
+/**
+* Tokenize `cmd` into `ParseEntry` items, preserving operators and comments.
+* Throws on unterminated quotes.
+*
+* @example
+*   parseShell('git commit -m "hello world"')
+*   // → ['git', 'commit', '-m', 'hello world']
+*
+*   parseShell('ls && echo done')
+*   // → ['ls', { op: '&&' }, 'echo', 'done']
+*
+*   parseShell('echo $HOME', { HOME: '/root' })
+*   // → ['echo', '/root']
+*/
+function parseShell(cmd, env) {
+	return (0, src_external_shell_quote.parse)(cmd, env);
+}
+
+//#endregion
+exports.parseShell = parseShell;

package/dist/shell/quote.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file Escape an argv array into a single shell-safe command string. Wraps the
+ *   vendored `shell-quote`. Use when building a command line for display, a log
+ *   line, or a copy-pasteable reproduction — the inverse of `parseShell`. The
+ *   output targets POSIX `sh` quoting, not `cmd.exe`; spawn callers should pass
+ *   an argv array to `child_process.spawn` directly rather than quoting into a
+ *   shell string.
+ */
+/**
+ * Escape an array of arguments into a shell-safe command string.
+ *
+ * @example
+ *   quote(['git', 'commit', '-m', 'hello world'])
+ *   // → "git commit -m 'hello world'"
+ *
+ *   quote(['echo', '$HOME'])
+ *   // → "echo \\$HOME"
+ */
+export declare function quote(argv: readonly string[]): string;

package/dist/shell/quote.js

@@ -0,0 +1,30 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let src_external_shell_quote = require("../external/shell-quote");
+
+//#region src/shell/quote.ts
+/**
+* @file Escape an argv array into a single shell-safe command string. Wraps the
+*   vendored `shell-quote`. Use when building a command line for display, a log
+*   line, or a copy-pasteable reproduction — the inverse of `parseShell`. The
+*   output targets POSIX `sh` quoting, not `cmd.exe`; spawn callers should pass
+*   an argv array to `child_process.spawn` directly rather than quoting into a
+*   shell string.
+*/
+/**
+* Escape an array of arguments into a shell-safe command string.
+*
+* @example
+*   quote(['git', 'commit', '-m', 'hello world'])
+*   // → "git commit -m 'hello world'"
+*
+*   quote(['echo', '$HOME'])
+*   // → "echo \\$HOME"
+*/
+function quote(argv) {
+	return (0, src_external_shell_quote.quote)(argv);
+}
+
+//#endregion
+exports.quote = quote;

package/dist/smol/detect.js

@@ -1,51 +1,75 @@
 "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 detect_exports = {};
-__export(detect_exports, {
-  getSmolUtil: () => getSmolUtil,
-  isSmol: () => isSmol
-});
-module.exports = __toCommonJS(detect_exports);
-var import_module = require("../node/module");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/detect.ts
+/**
+* @file 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.
+*/
+/**
+* Cached smol-binary detection result.
+*/
 let _isSmol;
+/**
+* Cached `node:smol-util` binding. `null` = probed and unavailable; `undefined`
+* = not yet probed. JS truthiness collapses both to "no binding" at the call
+* site.
+*/
 let _smolUtil;
 let _smolUtilProbed = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns `node:smol-util` when running on the smol Node binary, otherwise
+* `undefined`. Result is cached across calls.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSmolUtil() {
-  if (!_smolUtilProbed) {
-    _smolUtilProbed = true;
-    if ((0, import_module.isNodeBuiltin)("node:smol-util")) {
-      _smolUtil = require("node:smol-util");
-    }
-  }
-  return _smolUtil;
+	if (!_smolUtilProbed) {
+		_smolUtilProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-util")) _smolUtil = require("node:smol-util");
+	}
+	return _smolUtil;
 }
+/**
+* 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/detect'
+*
+*   if (isSmol()) {
+*     // running on the smol binary; native fast paths available
+*   }
+*   ```
+*/
 function isSmol() {
-  if (_isSmol === void 0) {
-    _isSmol = (0, import_module.isNodeBuiltin)("node:smol-util");
-  }
-  return _isSmol;
+	if (_isSmol === void 0) _isSmol = /* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-util");
+	return _isSmol;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSmolUtil,
-  isSmol
-});
+
+//#endregion
+exports.getSmolUtil = getSmolUtil;
+exports.isSmol = isSmol;

package/dist/smol/http.js

@@ -1,42 +1,38 @@
 "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 http_exports = {};
-__export(http_exports, {
-  getSmolHttp: () => getSmolHttp
-});
-module.exports = __toCommonJS(http_exports);
-var import_module = require("../node/module");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/http.ts
+/**
+* @file Lazy-loader for socket-btm's `node:smol-http`. `node:smol-http` is the
+*   C++-accelerated HTTP server + client binding shipped by socket-btm's smol
+*   Node binary. It backs a pipelined HTTP/1.1 + HTTP/2 client (`request`), a
+*   uWS-backed server (`serve`), and a family of fast-path response writers
+*   (`fastJsonResponse`, `fastErrorResponse`, etc.) that bypass the
+*   `http.ServerResponse` allocation hot path. Returns `undefined` on stock
+*   Node + non-Node runtimes. Result is cached across calls.
+*
+* @internal — `src/http-request/` is the natural consumer. Most
+*   callers should use the standard `httpRequest` / `httpJson` /
+*   `httpText` exports, which already route through this when smol
+*   is present.
+*/
 let _smolHttp;
 let _smolHttpProbed = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns `node:smol-http` when running on the smol Node binary, otherwise
+* `undefined`. Result is cached across calls.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSmolHttp() {
-  if (!_smolHttpProbed) {
-    _smolHttpProbed = true;
-    if ((0, import_module.isNodeBuiltin)("node:smol-http")) {
-      _smolHttp = require("node:smol-http");
-    }
-  }
-  return _smolHttp;
+	if (!_smolHttpProbed) {
+		_smolHttpProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-http")) _smolHttp = require("node:smol-http");
+	}
+	return _smolHttp;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSmolHttp
-});
+
+//#endregion
+exports.getSmolHttp = getSmolHttp;

package/dist/smol/https.js

@@ -1,42 +1,36 @@
 "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 https_exports = {};
-__export(https_exports, {
-  getSmolHttps: () => getSmolHttps
-});
-module.exports = __toCommonJS(https_exports);
-var import_module = require("../node/module");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/https.ts
+/**
+* @file Lazy-loader for socket-btm's `node:smol-https`. `node:smol-https` is
+*   the HTTPS-flavored server entry shipped by socket-btm's smol Node binary.
+*   It wraps `node:smol-http`'s `serve` with performance-oriented TLS defaults
+*   (X25519+P-256 curves, pre-vetted cipher list, 24-hour session timeout) and
+*   validates that TLS options are present. Returns `undefined` on stock Node +
+*   non-Node runtimes. Result is cached across calls.
+*
+* @internal — `src/http-request/` is the natural consumer. Most
+*   callers should use the standard server-side helpers, which
+*   route through this when smol is present.
+*/
 let _smolHttps;
 let _smolHttpsProbed = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns `node:smol-https` when running on the smol Node binary, otherwise
+* `undefined`. Result is cached across calls.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSmolHttps() {
-  if (!_smolHttpsProbed) {
-    _smolHttpsProbed = true;
-    if ((0, import_module.isNodeBuiltin)("node:smol-https")) {
-      _smolHttps = require("node:smol-https");
-    }
-  }
-  return _smolHttps;
+	if (!_smolHttpsProbed) {
+		_smolHttpsProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-https")) _smolHttps = require("node:smol-https");
+	}
+	return _smolHttps;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSmolHttps
-});
+
+//#endregion
+exports.getSmolHttps = getSmolHttps;

package/dist/smol/manifest.js

@@ -1,42 +1,38 @@
 "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 manifest_exports = {};
-__export(manifest_exports, {
-  getSmolManifest: () => getSmolManifest
-});
-module.exports = __toCommonJS(manifest_exports);
-var import_module = require("../node/module");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/manifest.ts
+/**
+* @file Lazy-loader for socket-btm's `node:smol-manifest`. `node:smol-manifest`
+*   is the manifest + lockfile parser exposed by socket-btm's smol Node binary.
+*   It parses package.json, package-lock (npm v1/v2/v3), yarn.lock (classic +
+*   berry), and pnpm-lock.yaml (v5/v6/v9) with internal primordial-hardened
+*   parsing. Returns `undefined` on stock Node + non-Node runtimes. Result is
+*   cached across calls. Callers fall back to the JS parsers under
+*   `src/eco/<pm>/parse-*` on the undefined path.
+*
+* @internal — used by `src/eco/manifest/*` leaves to resolve the
+*   smol-aware parsers. Most callers should import the specific leaf
+*   (`@socketsecurity/lib/eco/manifest/parse`), which already routes
+*   through this when smol is present.
+*/
 let _smolManifest;
 let _smolManifestProbed = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns `node:smol-manifest` when running on the smol Node binary, otherwise
+* `undefined`. Result is cached across calls.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSmolManifest() {
-  if (!_smolManifestProbed) {
-    _smolManifestProbed = true;
-    if ((0, import_module.isNodeBuiltin)("node:smol-manifest")) {
-      _smolManifest = require("node:smol-manifest");
-    }
-  }
-  return _smolManifest;
+	if (!_smolManifestProbed) {
+		_smolManifestProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-manifest")) _smolManifest = require("node:smol-manifest");
+	}
+	return _smolManifest;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSmolManifest
-});
+
+//#endregion
+exports.getSmolManifest = getSmolManifest;

package/dist/smol/path.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file Lazy-loader for socket-btm's `node:smol-path` — native fast paths for
+ *   the hot path-string primitives (`dirname`, `normalize`, …) and, per the
+ *   socket-btm `node-smol-path` Phase 4 plan, batched filesystem ops (`access`,
+ *   an in-C++ `findUp`). Returns `undefined` on stock Node, non-Node runtimes,
+ *   and on socket-btm binaries that haven't shipped the binding yet; callers
+ *   fall back to the JS implementation. Result is cached. The binding does not
+ *   exist yet (the plan is unbuilt) — this accessor is the seam so that when it
+ *   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find-up`
+ *   light up natively. Today `getSmolPath()` is always `undefined` and the JS
+ *   paths run.
+ */
+import type { PathLike } from 'node:fs';
+/**
+ * Native path / filesystem fast-path surface. Only the operations socket-lib's
+ * helpers shim are typed; the binding may expose more. Every method is optional
+ * so a partial rollout (e.g. `dirname` ships before `access`) still type-checks
+ * at the shim sites.
+ */
+export interface SmolPathBinding {
+    /**
+     * `path.dirname` over the one-byte Fast API. ASCII fast path; two-byte inputs
+     * route to the equivalent of `path.dirname`.
+     */
+    dirname?: ((p: string) => string) | undefined;
+    /**
+     * `path.normalize` over the one-byte Fast API.
+     */
+    normalize?: ((p: string) => string) | undefined;
+    /**
+     * `fs.accessSync`-equivalent returning a boolean instead of throwing — skips
+     * the V8 error-object materialization the JS wrapper pays on every negative
+     * check. `mode` is an `fs.constants` bit.
+     */
+    access?: ((path: PathLike, mode?: number | undefined) => boolean) | undefined;
+    /**
+     * In-C++ find-up: walk `startDir`'s ancestors, return the first dir
+     * containing any of `names` (as a file unless `onlyDirectories`), or
+     * `undefined`. Collapses the N JS↔native crossings of the JS walk into one.
+     */
+    findUp?: ((startDir: string, names: readonly string[], options?: {
+        onlyDirectories?: boolean | undefined;
+    } | undefined) => string | undefined) | undefined;
+}
+/**
+ * Returns the `node:smol-path` binding when running on a smol Node binary that
+ * ships it; otherwise `undefined`. Cached across calls.
+ *
+ * @returns The native binding, or `undefined` to signal "use the JS fallback".
+ */
+export declare function getSmolPath(): SmolPathBinding | undefined;

package/dist/smol/path.js

@@ -0,0 +1,38 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/path.ts
+/**
+* @file Lazy-loader for socket-btm's `node:smol-path` — native fast paths for
+*   the hot path-string primitives (`dirname`, `normalize`, …) and, per the
+*   socket-btm `node-smol-path` Phase 4 plan, batched filesystem ops (`access`,
+*   an in-C++ `findUp`). Returns `undefined` on stock Node, non-Node runtimes,
+*   and on socket-btm binaries that haven't shipped the binding yet; callers
+*   fall back to the JS implementation. Result is cached. The binding does not
+*   exist yet (the plan is unbuilt) — this accessor is the seam so that when it
+*   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find-up`
+*   light up natively. Today `getSmolPath()` is always `undefined` and the JS
+*   paths run.
+*/
+let _smolPath;
+let _smolPathProbed = false;
+/**
+* Returns the `node:smol-path` binding when running on a smol Node binary that
+* ships it; otherwise `undefined`. Cached across calls.
+*
+* @returns The native binding, or `undefined` to signal "use the JS fallback".
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getSmolPath() {
+	if (!_smolPathProbed) {
+		_smolPathProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-path")) _smolPath = require("node:smol-path");
+	}
+	return _smolPath;
+}
+
+//#endregion
+exports.getSmolPath = getSmolPath;

package/dist/smol/primordial.js

@@ -1,42 +1,40 @@
 "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_module = require("../node/module");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_module = require('../node/module.js');
+
+//#region src/smol/primordial.ts
+/**
+* @file 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
+*/
 let _smolPrimordial;
 let _smolPrimordialProbed = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Returns `node:smol-primordial` when running on the smol Node binary,
+* otherwise `undefined`. Result is cached across calls.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSmolPrimordial() {
-  if (!_smolPrimordialProbed) {
-    _smolPrimordialProbed = true;
-    if ((0, import_module.isNodeBuiltin)("node:smol-primordial")) {
-      _smolPrimordial = require("node:smol-primordial");
-    }
-  }
-  return _smolPrimordial;
+	if (!_smolPrimordialProbed) {
+		_smolPrimordialProbed = true;
+		/* c8 ignore start - smol Node binary only. */
+		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-primordial")) _smolPrimordial = require("node:smol-primordial");
+	}
+	return _smolPrimordial;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getSmolPrimordial
-});
+
+//#endregion
+exports.getSmolPrimordial = getSmolPrimordial;