@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/secrets/windows.js

@@ -0,0 +1,318 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var windows_exports = {};
+__export(windows_exports, {
+  buildTarget: () => buildTarget,
+  deleteWindows: () => deleteWindows,
+  deleteWindowsSync: () => deleteWindowsSync,
+  getDpapiFilePath: () => getDpapiFilePath,
+  isWindowsBackendAvailable: () => isWindowsBackendAvailable,
+  quotePs: () => quotePs,
+  readDpapi: () => readDpapi,
+  readDpapiSync: () => readDpapiSync,
+  readWindows: () => readWindows,
+  readWindowsSync: () => readWindowsSync,
+  runPsAsync: () => runPsAsync,
+  runPsSync: () => runPsSync,
+  validateKeychainComponent: () => validateKeychainComponent,
+  writeDpapi: () => writeDpapi,
+  writeDpapiSync: () => writeDpapiSync,
+  writeWindows: () => writeWindows,
+  writeWindowsSync: () => writeWindowsSync
+});
+module.exports = __toCommonJS(windows_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+const POWERSHELL_BIN = "powershell";
+function buildTarget(service, account) {
+  return `${service}:${account}`;
+}
+async function deleteWindows(service, account) {
+  const target = buildTarget(service, account);
+  let removedAny = false;
+  const psScript = `
+    try { Remove-StoredCredential -Target ${quotePs(target)}; exit 0 }
+    catch { exit 1 }
+  `;
+  const ps = await runPsAsync(psScript);
+  if (ps.status === 0) {
+    removedAny = true;
+  }
+  const filePath = getDpapiFilePath(service, account);
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    try {
+      const { rmSync } = await import("node:fs");
+      rmSync(filePath, { force: true });
+      removedAny = true;
+    } catch {
+    }
+  }
+  return removedAny ? "removed" : "absent";
+}
+function deleteWindowsSync(service, account) {
+  const target = buildTarget(service, account);
+  let removedAny = false;
+  const psScript = `
+    try { Remove-StoredCredential -Target ${quotePs(target)}; exit 0 }
+    catch { exit 1 }
+  `;
+  const ps = runPsSync(psScript);
+  if (ps.status === 0) {
+    removedAny = true;
+  }
+  const filePath = getDpapiFilePath(service, account);
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    try {
+      const fsMod = require("node:fs");
+      fsMod.rmSync(filePath, { force: true });
+      removedAny = true;
+    } catch {
+    }
+  }
+  return removedAny ? "removed" : "absent";
+}
+function getDpapiFilePath(service, account) {
+  validateKeychainComponent(service, "service");
+  validateKeychainComponent(account, "account");
+  const appData = import_node_process.default.env["APPDATA"] ?? import_node_path.default.join((0, import_node_os.homedir)(), "AppData", "Roaming");
+  return import_node_path.default.join(appData, service, `${account}.enc`);
+}
+function isWindowsBackendAvailable() {
+  const r = (0, import_node_child_process.spawnSync)(POWERSHELL_BIN, ["-NoProfile", "-Command", "exit 0"], {
+    stdio: "ignore"
+  });
+  return r.status === 0;
+}
+function quotePs(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function readDpapi(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    return void 0;
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [Convert]::FromBase64String((Get-Content -Raw ${quotePs(filePath)}))
+    $plain = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [System.Text.Encoding]::UTF8.GetString($plain)
+  `;
+  const r = await runPsAsync(script);
+  if (r.status !== 0) {
+    return void 0;
+  }
+  const out = r.stdout.trim();
+  return out || void 0;
+}
+function readDpapiSync(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    return void 0;
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [Convert]::FromBase64String((Get-Content -Raw ${quotePs(filePath)}))
+    $plain = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [System.Text.Encoding]::UTF8.GetString($plain)
+  `;
+  const r = runPsSync(script);
+  if (r.status !== 0) {
+    return void 0;
+  }
+  const out = r.stdout.trim();
+  return out || void 0;
+}
+async function readWindows(service, account) {
+  const target = buildTarget(service, account);
+  const script = `
+    try {
+      (Get-StoredCredential -Target ${quotePs(target)}).Password |
+        ConvertFrom-SecureString -AsPlainText
+    } catch { exit 1 }
+  `;
+  const ps = await runPsAsync(script);
+  if (ps.status === 0) {
+    const out = ps.stdout.trim();
+    if (out) {
+      return out;
+    }
+  }
+  return readDpapi(getDpapiFilePath(service, account));
+}
+function readWindowsSync(service, account) {
+  const target = buildTarget(service, account);
+  const script = `
+    try {
+      (Get-StoredCredential -Target ${quotePs(target)}).Password |
+        ConvertFrom-SecureString -AsPlainText
+    } catch { exit 1 }
+  `;
+  const ps = runPsSync(script);
+  if (ps.status === 0) {
+    const out = ps.stdout.trim();
+    if (out) {
+      return out;
+    }
+  }
+  return readDpapiSync(getDpapiFilePath(service, account));
+}
+function runPsAsync(script, input) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process.spawn)(POWERSHELL_BIN, ["-NoProfile", "-Command", script], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", () => resolve({ status: -1, stdout, stderr }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
+    if (input !== void 0) {
+      child.stdin.end(input);
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+function runPsSync(script, input) {
+  const r = (0, import_node_child_process.spawnSync)(POWERSHELL_BIN, ["-NoProfile", "-Command", script], {
+    encoding: "utf8",
+    input,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return { status: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+function validateKeychainComponent(value, name) {
+  if (/[\\/]/.test(value) || value.includes("..") || value.includes("\0") || value === "" || value === ".") {
+    throw new Error(
+      `secrets/windows: ${name} contains path-traversal characters: ${JSON.stringify(value)}. Use a plain identifier (no \\\\, /, .., or NUL).`
+    );
+  }
+}
+async function writeDpapi(filePath, value) {
+  const dir = import_node_path.default.dirname(filePath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $token = [Console]::In.ReadToEnd().Trim()
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($token)
+    $protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($protected) | Set-Content -Path ${quotePs(filePath)} -NoNewline
+  `;
+  const r = await runPsAsync(script, value);
+  if (r.status !== 0) {
+    throw new Error(
+      `DPAPI file write failed: ${r.stderr.trim()}. Install the CredentialManager PowerShell module (\`Install-Module CredentialManager -Scope CurrentUser\`) for a cleaner storage path.`
+    );
+  }
+}
+function writeDpapiSync(filePath, value) {
+  const dir = import_node_path.default.dirname(filePath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  const script = `
+    Add-Type -AssemblyName System.Security
+    $token = [Console]::In.ReadToEnd().Trim()
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($token)
+    $protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($protected) | Set-Content -Path ${quotePs(filePath)} -NoNewline
+  `;
+  const r = runPsSync(script, value);
+  if (r.status !== 0) {
+    throw new Error(
+      `DPAPI file write failed: ${r.stderr.trim()}. Install the CredentialManager PowerShell module (\`Install-Module CredentialManager -Scope CurrentUser\`) for a cleaner storage path.`
+    );
+  }
+}
+async function writeWindows(service, account, value, _label) {
+  const target = buildTarget(service, account);
+  const psScript = `
+    $token = $input | Out-String
+    $token = $token.Trim()
+    $secure = ConvertTo-SecureString $token -AsPlainText -Force
+    try {
+      New-StoredCredential -Target ${quotePs(target)} -UserName ${quotePs(account)} -SecurePassword $secure -Persist LocalMachine | Out-Null
+      exit 0
+    } catch { exit 1 }
+  `;
+  const ps = await runPsAsync(psScript, value);
+  if (ps.status === 0) {
+    return;
+  }
+  await writeDpapi(getDpapiFilePath(service, account), value);
+}
+function writeWindowsSync(service, account, value, _label) {
+  const target = buildTarget(service, account);
+  const psScript = `
+    $token = $input | Out-String
+    $token = $token.Trim()
+    $secure = ConvertTo-SecureString $token -AsPlainText -Force
+    try {
+      New-StoredCredential -Target ${quotePs(target)} -UserName ${quotePs(account)} -SecurePassword $secure -Persist LocalMachine | Out-Null
+      exit 0
+    } catch { exit 1 }
+  `;
+  const ps = runPsSync(psScript, value);
+  if (ps.status === 0) {
+    return;
+  }
+  writeDpapiSync(getDpapiFilePath(service, account), value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTarget,
+  deleteWindows,
+  deleteWindowsSync,
+  getDpapiFilePath,
+  isWindowsBackendAvailable,
+  quotePs,
+  readDpapi,
+  readDpapiSync,
+  readWindows,
+  readWindowsSync,
+  runPsAsync,
+  runPsSync,
+  validateKeychainComponent,
+  writeDpapi,
+  writeDpapiSync,
+  writeWindows,
+  writeWindowsSync
+});

package/dist/shadow/skip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Shadow binary installation utilities for Socket ecosystem. Provides
+ *   logic to determine when shadow binary installation should be skipped.
+ */
+import type { ShadowInstallationOptions } from './types';
+/**
+ * Determines if shadow binaries should be installed. Shadows should NOT be
+ * installed when: - Running in a temporary execution context (exec/npx/dlx) -
+ * On Windows with an existing binary path (required for Windows to function)
+ *
+ * @example
+ *   ;```typescript
+ *   if (shouldSkipShadow(binPath, { cwd: process.cwd() })) {
+ *     console.log('Skipping shadow binary installation')
+ *   }
+ *   ```
+ *
+ * @param binPath - Path to the binary being shadowed.
+ * @param options - Configuration options.
+ * @param options.cwd - Current working directory path to check.
+ * @param options.win32 - Whether running on Windows.
+ *
+ * @returns True if shadow installation should be skipped
+ */
+export declare function shouldSkipShadow(binPath: string, options?: ShadowInstallationOptions | undefined): boolean;

package/dist/{shadow.js → shadow/skip.js}

@@ -28,13 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var shadow_exports = {};
-__export(shadow_exports, {
+var skip_exports = {};
+__export(skip_exports, {
   shouldSkipShadow: () => shouldSkipShadow
 });
-module.exports = __toCommonJS(shadow_exports);
+module.exports = __toCommonJS(skip_exports);
 var import_node_process = __toESM(require("node:process"));
-var import_normalize = require("./paths/normalize");
+var import_normalize = require("../paths/normalize");
 function shouldSkipShadow(binPath, options) {
   const { cwd = import_node_process.default.cwd(), win32 = false } = {
     __proto__: null,

package/dist/shadow/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Public type surface for `shadow/*` modules — the
+ *   `ShadowInstallationOptions` record. Pure types, no runtime side effects.
+ */
+export interface ShadowInstallationOptions {
+    cwd?: string | undefined;
+    win32?: boolean | undefined;
+}

package/dist/shadow/types.js

@@ -0,0 +1,18 @@
+"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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/smol/detect.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @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.
+ */
+/**
+ * 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;
+/**
+ * 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
+ *   }
+ *   ```
+ */
+export declare function isSmol(): boolean;

package/dist/smol/{util.js → detect.js}

@@ -18,39 +18,31 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var util_exports = {};
-__export(util_exports, {
+var detect_exports = {};
+__export(detect_exports, {
   getSmolUtil: () => getSmolUtil,
   isSmol: () => isSmol
 });
-module.exports = __toCommonJS(util_exports);
+module.exports = __toCommonJS(detect_exports);
+var import_module = require("../node/module");
 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;
+let _smolUtilProbed = false;
 // @__NO_SIDE_EFFECTS__
 function getSmolUtil() {
-  if (_smolUtil === void 0) {
-    if (isSmol()) {
-      try {
-        _smolUtil = require("node:smol-util");
-      } catch {
-        _smolUtil = null;
-      }
-    } else {
-      _smolUtil = null;
+  if (!_smolUtilProbed) {
+    _smolUtilProbed = true;
+    if ((0, import_module.isNodeBuiltin)("node:smol-util")) {
+      _smolUtil = require("node:smol-util");
     }
   }
-  return _smolUtil ?? void 0;
+  return _smolUtil;
+}
+function isSmol() {
+  if (_isSmol === void 0) {
+    _isSmol = (0, import_module.isNodeBuiltin)("node:smol-util");
+  }
+  return _isSmol;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/smol/http.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @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.
+ */
+/**
+ * Options accepted by `smol-http`'s `request()`. The full surface is larger;
+ * socket-lib types only the fields it actually reads. Callers needing more can
+ * widen the type at the callsite.
+ */
+export interface SmolHttpRequestOptions {
+    readonly method?: string | undefined;
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    readonly body?: string | Buffer | undefined;
+    readonly timeout?: number | undefined;
+}
+/**
+ * Surface of `node:smol-http`. See socket-btm's
+ * additions/source-patched/lib/smol-http.js (and the
+ * `internal/socketsecurity/http/core.js` barrel it re-exports) for the
+ * canonical shape.
+ *
+ * Only the entries socket-lib's `http-request/` module needs are typed here.
+ * The full surface (server-side `serve`, uWS-backed `fast*Response` writers,
+ * `withCork`, `setPipelining`, etc.) is available as `Record<string, unknown>`
+ * for callers that need it without expanding the contract here.
+ */
+export interface SmolHttpBinding {
+    /**
+     * Lean pipelining-aware HTTP client. Signature mirrors `node:http`'s
+     * `request` but returns a thinner-allocation response.
+     */
+    request(url: string, options?: SmolHttpRequestOptions): Promise<unknown>;
+    /**
+     * Toggle pipelining on the shared client pool. On by default.
+     */
+    setPipelining(enabled: boolean): void;
+    /**
+     * `true` if the binary was built with io_uring support (Linux only).
+     */
+    readonly isIoUringAvailable: boolean;
+    /**
+     * `true` if the binary was built with mimalloc.
+     */
+    readonly isMimallocAvailable: boolean;
+}
+/**
+ * Returns `node:smol-http` when running on the smol Node binary, otherwise
+ * `undefined`. Result is cached across calls.
+ */
+export declare function getSmolHttp(): SmolHttpBinding | undefined;

package/dist/smol/http.js

@@ -0,0 +1,42 @@
+"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");
+let _smolHttp;
+let _smolHttpProbed = false;
+// @__NO_SIDE_EFFECTS__
+function getSmolHttp() {
+  if (!_smolHttpProbed) {
+    _smolHttpProbed = true;
+    if ((0, import_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
+});