@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/signal-exit/lifecycle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file `load` and `unload` — install and remove the `signal-exit` listeners.
+ *   Co-located with `getSignalListeners` because the per-signal listener body
+ *   calls `unload()`; keeping them in the same leaf avoids an inter-leaf import
+ *   cycle.
+ */
+import type { SignalListenerMap } from './types';
+export declare function getSignalListeners(): SignalListenerMap;
+/**
+ * Load signal handlers and hook into process exit events.
+ *
+ * @example
+ *   ;```typescript
+ *   load()
+ *   // Signal handlers are now active
+ *   ```
+ */
+export declare function load(): void;
+/**
+ * Unload signal handlers and restore original process behavior.
+ *
+ * @example
+ *   ;```typescript
+ *   unload()
+ *   // Signal handlers are now removed
+ *   ```
+ */
+export declare function unload(): void;

package/dist/signal-exit/lifecycle.js

@@ -0,0 +1,109 @@
+"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 lifecycle_exports = {};
+__export(lifecycle_exports, {
+  getSignalListeners: () => getSignalListeners,
+  load: () => load,
+  unload: () => unload
+});
+module.exports = __toCommonJS(lifecycle_exports);
+var import_internal = require("./_internal");
+var import_intercept = require("./intercept");
+let _sigListeners;
+// @__NO_SIDE_EFFECTS__
+function getSignalListeners() {
+  if (_sigListeners === void 0) {
+    _sigListeners = { __proto__: null };
+    const emitter = (0, import_internal.getEmitter)();
+    const sigs = (0, import_internal.getSignals)();
+    for (const sig of sigs) {
+      _sigListeners[sig] = function listener() {
+        const listeners = import_internal.globalProcess?.listeners(sig) || [];
+        if (listeners.length === emitter.count) {
+          /* @__PURE__ */ unload();
+          (0, import_internal.emit)("exit", void 0, sig);
+          (0, import_internal.emit)("afterexit", void 0, sig);
+          const killSig = import_internal.WIN32 && sig === "SIGHUP" ? "SIGINT" : sig;
+          import_internal.globalProcess?.kill(import_internal.globalProcess?.pid, killSig);
+        }
+      };
+    }
+  }
+  return _sigListeners;
+}
+// @__NO_SIDE_EFFECTS__
+function load() {
+  if ((0, import_internal.isLoaded)() || !import_internal.globalProcess) {
+    return;
+  }
+  (0, import_internal.setLoaded)(true);
+  const proc = import_internal.globalProcess;
+  const emitter = (0, import_internal.getEmitter)();
+  if (emitter.count !== void 0) {
+    emitter.count += 1;
+  }
+  const sigs = (0, import_internal.getSignals)();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  (0, import_internal.setSignals)(
+    sigs.filter((sig) => {
+      try {
+        proc.on(sig, sigListeners[sig]);
+        return true;
+      } catch {
+      }
+      return false;
+    })
+  );
+  proc.emit = import_intercept.processEmit;
+  proc.reallyExit = import_intercept.processReallyExit;
+}
+// @__NO_SIDE_EFFECTS__
+function unload() {
+  if (!(0, import_internal.isLoaded)() || !import_internal.globalProcess) {
+    return;
+  }
+  (0, import_internal.setLoaded)(false);
+  const sigs = (0, import_internal.getSignals)();
+  const sigListeners = /* @__PURE__ */ getSignalListeners();
+  for (const sig of sigs) {
+    try {
+      import_internal.globalProcess.removeListener(
+        sig,
+        sigListeners[sig]
+      );
+    } catch {
+    }
+  }
+  import_internal.globalProcess.emit = import_internal.originalProcessEmit;
+  if (import_internal.originalProcessReallyExit !== void 0) {
+    import_internal.globalProcess.reallyExit = import_internal.originalProcessReallyExit;
+  }
+  const emitter = (0, import_internal.getEmitter)();
+  if (emitter.count !== void 0) {
+    emitter.count -= 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSignalListeners,
+  load,
+  unload
+});

package/dist/signal-exit/register.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file `onExit` — register a callback for process exit / signal. Triggers
+ *   `load()` on first call. Returns a remover that unregisters the callback and
+ *   calls `unload()` once both `exit` and `afterexit` listener lists empty
+ *   out.
+ */
+import type { OnExitOptions } from './types';
+/**
+ * Register a callback to run on process exit or signal.
+ *
+ * @example
+ *   ```typescript
+ *   const remove = onExit((code, signal) => {
+ *   console.log(`Exiting with code ${code}, signal ${signal}`)
+ *   })
+ *   // Later, to unregister:
+ *   remove()
+ *   ```
+ */
+export declare function onExit(cb: (code: number | null, signal: string | null) => void, options?: OnExitOptions | undefined): () => void;

package/dist/signal-exit/register.js

@@ -0,0 +1,58 @@
+"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 register_exports = {};
+__export(register_exports, {
+  onExit: () => onExit
+});
+module.exports = __toCommonJS(register_exports);
+var import_error = require("../primordials/error");
+var import_internal = require("./_internal");
+var import_lifecycle = require("./lifecycle");
+// @__NO_SIDE_EFFECTS__
+function onExit(cb, options) {
+  if (!import_internal.globalProcess) {
+    return function remove() {
+    };
+  }
+  if (typeof cb !== "function") {
+    throw new import_error.TypeErrorCtor("a callback must be provided for exit handler");
+  }
+  if ((0, import_internal.isLoaded)() === false) {
+    (0, import_lifecycle.load)();
+  }
+  const { alwaysLast } = { __proto__: null, ...options };
+  let eventName = "exit";
+  if (alwaysLast) {
+    eventName = "afterexit";
+  }
+  const emitter = (0, import_internal.getEmitter)();
+  emitter.on(eventName, cb);
+  return function remove() {
+    emitter.removeListener(eventName, cb);
+    if (!emitter.listeners("exit").length && !emitter.listeners("afterexit").length) {
+      (0, import_lifecycle.unload)();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onExit
+});

package/dist/signal-exit/signals.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file `signals()` — list the signals this process is watching. Before
+ *   `load()` runs, returns the lazy-initialised default list; after `load()`
+ *   runs, returns the filtered subset that was actually registered
+ *   successfully.
+ */
+/**
+ * Get the list of signals that are currently being monitored.
+ *
+ * @example
+ *   ;```typescript
+ *   const sigs = signals()
+ *   console.log(sigs) // ['SIGABRT', 'SIGALRM', 'SIGHUP', ...]
+ *   ```
+ */
+export declare function signals(): string[];

package/dist/signal-exit/signals.js

@@ -0,0 +1,34 @@
+"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 signals_exports = {};
+__export(signals_exports, {
+  signals: () => signals
+});
+module.exports = __toCommonJS(signals_exports);
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function signals() {
+  return (0, import_internal.getSignals)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  signals
+});

package/dist/signal-exit/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Public type surface for `signal-exit/*` modules — the `OnExitOptions`
+ *   consumed by `onExit`, plus the shared internal types for the signal
+ *   emitter, emitted-signal map, and listener map. Pure types, no runtime side
+ *   effects.
+ */
+export type EmittedSignals = {
+    [signal: string]: boolean;
+};
+export type SignalExitEmitter = import('node:events').EventEmitter & {
+    count?: number;
+    emitted?: EmittedSignals;
+    infinite?: boolean;
+};
+export type SignalListener = () => void;
+export type SignalListenerMap = {
+    [signal: string]: SignalListener;
+};
+export interface OnExitOptions {
+    alwaysLast?: boolean;
+}

package/dist/signal-exit/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
+});

package/dist/smol/https.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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.
+ */
+/**
+ * TLS options accepted by `smol-https`'s `serve()`. Mirrors Node's
+ * `tls.TlsOptions` for the fields socket-lib reads; callers needing more can
+ * widen the type at the callsite.
+ */
+export interface SmolHttpsTlsOptions {
+    readonly key?: Buffer | string | undefined;
+    readonly cert?: Buffer | string | undefined;
+    readonly ca?: Buffer | string | ReadonlyArray<Buffer | string> | undefined;
+    readonly passphrase?: string | undefined;
+    readonly sessionTimeout?: number | undefined;
+    readonly honorCipherOrder?: boolean | undefined;
+    readonly ecdhCurve?: string | undefined;
+    readonly ciphers?: string | undefined;
+}
+/**
+ * Options accepted by `smol-https`'s `serve()`. Mirrors `smol-http`'s `serve`
+ * options + TLS extensions.
+ */
+export interface SmolHttpsServeOptions {
+    readonly port?: number | undefined;
+    readonly hostname?: string | undefined;
+    readonly key?: Buffer | string | undefined;
+    readonly cert?: Buffer | string | undefined;
+    readonly ca?: Buffer | string | ReadonlyArray<Buffer | string> | undefined;
+    readonly passphrase?: string | undefined;
+    readonly tls?: SmolHttpsTlsOptions | undefined;
+    fetch(request: unknown): unknown | Promise<unknown>;
+}
+/**
+ * Surface of `node:smol-https`. See socket-btm's
+ * additions/source-patched/lib/smol-https.js for the canonical shape — a single
+ * `serve()` factory backed by `smol-http.serve()` plus injected fast-TLS
+ * defaults.
+ */
+export interface SmolHttpsBinding {
+    /**
+     * Create an HTTPS server. Throws `TypeError` when no TLS options are provided
+     * (use `node:smol-http`'s `serve()` for plain HTTP).
+     */
+    serve(options: SmolHttpsServeOptions): unknown;
+}
+/**
+ * Returns `node:smol-https` when running on the smol Node binary, otherwise
+ * `undefined`. Result is cached across calls.
+ */
+export declare function getSmolHttps(): SmolHttpsBinding | undefined;

package/dist/smol/https.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 https_exports = {};
+__export(https_exports, {
+  getSmolHttps: () => getSmolHttps
+});
+module.exports = __toCommonJS(https_exports);
+var import_module = require("../node/module");
+let _smolHttps;
+let _smolHttpsProbed = false;
+// @__NO_SIDE_EFFECTS__
+function getSmolHttps() {
+  if (!_smolHttpsProbed) {
+    _smolHttpsProbed = true;
+    if ((0, import_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
+});