@socketsecurity/lib 5.26.0 → 5.27.0

package/dist/http-request.js

@@ -33,8 +33,10 @@ __export(http_request_exports, {
   sanitizeHeaders: () => sanitizeHeaders
 });
 module.exports = __toCommonJS(http_request_exports);
+var import_promises = require("node:timers/promises");
 var import_socket = require("./constants/socket");
 var import_fs = require("./fs");
+var import_primordials = require("./primordials");
 class HttpResponseError extends Error {
   response;
   constructor(response, message) {
@@ -104,19 +106,24 @@ async function httpDownloadAttempt(url, destPath, options) {
   }
   const res = response.rawResponse;
   if (!res) {
-    throw new Error("Stream response missing rawResponse");
+    throw new import_primordials.ErrorCtor("Stream response missing rawResponse");
   }
   const { createWriteStream } = /* @__PURE__ */ getFs();
-  const totalSize = Number.parseInt(
+  const totalSize = (0, import_primordials.NumberParseInt)(
     response.headers["content-length"] || "0",
     10
   );
-  return await new Promise((resolve, reject) => {
+  return await new import_primordials.PromiseCtor((resolve, reject) => {
     let downloadedSize = 0;
     const fileStream = createWriteStream(destPath);
     const cleanupPartial = () => {
-      (/* @__PURE__ */ getFs()).promises.unlink(destPath).catch(() => {
-      });
+      ;
+      (async () => {
+        try {
+          await (/* @__PURE__ */ getFs()).promises.unlink(destPath);
+        } catch {
+        }
+      })();
     };
     fileStream.on("error", (error) => {
       fileStream.destroy();
@@ -164,7 +171,7 @@ async function httpRequestAttempt(url, options) {
     stream = false,
     timeout = 3e4
   } = { __proto__: null, ...options };
-  const startTime = Date.now();
+  const startTime = (0, import_primordials.DateNow)();
   const streamHeaders = body && typeof body === "object" && "getHeaders" in body && typeof body.getHeaders === "function" ? body.getHeaders() : void 0;
   const mergedHeaders = {
     "User-Agent": import_socket.SOCKET_LIB_USER_AGENT,
@@ -172,7 +179,7 @@ async function httpRequestAttempt(url, options) {
     ...headers
   };
   hooks?.onRequest?.({ method, url, headers: mergedHeaders, timeout });
-  return await new Promise((resolve, reject) => {
+  return await new import_primordials.PromiseCtor((resolve, reject) => {
     let settled = false;
     const resolveOnce = (response) => {
       if (settled) {
@@ -193,7 +200,7 @@ async function httpRequestAttempt(url, options) {
       emitResponse({ error: err });
       reject(err);
     };
-    const parsedUrl = new URL(url);
+    const parsedUrl = new import_primordials.URLCtor(url);
     const isHttps = parsedUrl.protocol === "https:";
     const httpModule = isHttps ? /* @__PURE__ */ getHttps() : /* @__PURE__ */ getHttp();
     const requestOptions = {
@@ -210,7 +217,7 @@ async function httpRequestAttempt(url, options) {
     const emitResponse = (info) => {
       try {
         hooks?.onResponse?.({
-          duration: Date.now() - startTime,
+          duration: (0, import_primordials.DateNow)() - startTime,
           method,
           url,
           ...info
@@ -429,7 +436,7 @@ async function fetchChecksums(url, options) {
   };
   const response = await httpRequest(url, { ca, headers, timeout });
   if (!response.ok) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `Failed to fetch checksums from ${url}: ${response.status} ${response.statusText}`
     );
   }
@@ -455,7 +462,7 @@ async function httpDownload(url, destPath, options) {
   } else if (logger) {
     let lastPercent = 0;
     progressCallback = (downloaded, total) => {
-      const percent = total === 0 ? 0 : Math.floor(downloaded / total * 100);
+      const percent = total === 0 ? 0 : (0, import_primordials.MathFloor)(downloaded / total * 100);
       if (percent >= lastPercent + progressInterval) {
         logger.log(
           `  Progress: ${percent}% (${(downloaded / 1024 / 1024).toFixed(1)} MB / ${(total / 1024 / 1024).toFixed(1)} MB)`
@@ -487,11 +494,11 @@ async function httpDownload(url, destPath, options) {
         const computedHash = crypto.createHash("sha256").update(fileContent).digest("hex");
         const expectedHash = sha256.toLowerCase();
         if (computedHash.length !== expectedHash.length || !crypto.timingSafeEqual(
-          Buffer.from(computedHash),
+          (0, import_primordials.BufferFrom)(computedHash),
           Buffer.from(expectedHash)
         )) {
           await (0, import_fs.safeDelete)(tempPath);
-          throw new Error(
+          throw new import_primordials.ErrorCtor(
             `Checksum verification failed for ${url}
 Expected: ${expectedHash}
 Computed: ${computedHash}`
@@ -512,10 +519,10 @@ Computed: ${computedHash}`
         break;
       }
       const delayMs = retryDelay * 2 ** attempt;
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await (0, import_promises.setTimeout)(delayMs);
     }
   }
-  throw lastError || new Error("Download failed after retries");
+  throw lastError || new import_primordials.ErrorCtor("Download failed after retries");
 }
 async function httpJson(url, options) {
   const {
@@ -547,7 +554,7 @@ async function httpJson(url, options) {
   try {
     return response.json();
   } catch (e) {
-    throw new Error("Failed to parse JSON response", { cause: e });
+    throw new import_primordials.ErrorCtor("Failed to parse JSON response", { cause: e });
   }
 }
 async function httpRequest(url, options) {
@@ -569,7 +576,7 @@ async function httpRequest(url, options) {
   } = { __proto__: null, ...options };
   const isStreamBody = body !== void 0 && typeof body === "object" && typeof body.pipe === "function";
   if (isStreamBody && retries > 0) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       "Streaming body (Readable/FormData) cannot be used with retries. Streams are consumed on first attempt and cannot be replayed. Set retries: 0 or buffer the body as a string/Buffer."
     );
   }
@@ -606,14 +613,14 @@ async function httpRequest(url, options) {
         if (retryResult === false) {
           break;
         }
-        const actualDelay = typeof retryResult === "number" && !Number.isNaN(retryResult) ? Math.max(0, retryResult) : delayMs;
-        await new Promise((resolve) => setTimeout(resolve, actualDelay));
+        const actualDelay = typeof retryResult === "number" && !(0, import_primordials.NumberIsNaN)(retryResult) ? (0, import_primordials.MathMax)(0, retryResult) : delayMs;
+        await (0, import_promises.setTimeout)(actualDelay);
       } else {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await (0, import_promises.setTimeout)(delayMs);
       }
     }
   }
-  throw lastError || new Error("Request failed after retries");
+  throw lastError || new import_primordials.ErrorCtor("Request failed after retries");
 }
 async function httpText(url, options) {
   const {
@@ -649,9 +656,9 @@ const CHECKSUM_GNU_RE = /^([a-fA-F0-9]{64})\s+(.+)$/;
 const RETRY_AFTER_INT_RE = /^\d+$/;
 function parseChecksums(text) {
   const checksums = { __proto__: null };
-  for (const line of text.split("\n")) {
+  for (const line of (0, import_primordials.StringPrototypeSplit)(text, "\n")) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
+    if (!trimmed || (0, import_primordials.StringPrototypeStartsWith)(trimmed, "#")) {
       continue;
     }
     const bsdMatch = CHECKSUM_BSD_RE.exec(trimmed);
@@ -670,7 +677,7 @@ function parseRetryAfterHeader(value) {
   if (!value) {
     return void 0;
   }
-  const raw = Array.isArray(value) ? value[0] : value;
+  const raw = (0, import_primordials.ArrayIsArray)(value) ? value[0] : value;
   if (!raw) {
     return void 0;
   }
@@ -679,9 +686,9 @@ function parseRetryAfterHeader(value) {
     const seconds = Number(trimmed);
     return seconds * 1e3;
   }
-  const date = new Date(raw);
-  if (!Number.isNaN(date.getTime())) {
-    const delayMs = date.getTime() - Date.now();
+  const date = new import_primordials.DateCtor(raw);
+  if (!(0, import_primordials.NumberIsNaN)(date.getTime())) {
+    const delayMs = date.getTime() - (0, import_primordials.DateNow)();
     if (delayMs > 0) {
       return delayMs;
     }
@@ -693,7 +700,7 @@ async function readIncomingResponse(msg) {
   for await (const chunk of msg) {
     chunks.push(chunk);
   }
-  const body = Buffer.concat(chunks);
+  const body = (0, import_primordials.BufferConcat)(chunks);
   const status = msg.statusCode ?? 0;
   const statusText = msg.statusMessage ?? "";
   return {
@@ -703,7 +710,7 @@ async function readIncomingResponse(msg) {
     ),
     body,
     headers: msg.headers,
-    json: () => JSON.parse(body.toString("utf8")),
+    json: () => (0, import_primordials.JSONParse)(body.toString("utf8")),
     ok: status >= 200 && status < 300,
     rawResponse: msg,
     status,
@@ -715,7 +722,7 @@ function sanitizeHeaders(headers) {
   if (!headers) {
     return {};
   }
-  const sensitiveHeaders = /* @__PURE__ */ new Set([
+  const sensitiveHeaders = new import_primordials.SetCtor([
     "authorization",
     "cookie",
     "proxy-authorization",
@@ -726,11 +733,11 @@ function sanitizeHeaders(headers) {
   const result = {
     __proto__: null
   };
-  for (const key of Object.keys(headers)) {
+  for (const key of (0, import_primordials.ObjectKeys)(headers)) {
     const value = headers[key];
     if (sensitiveHeaders.has(key.toLowerCase())) {
       result[key] = "[REDACTED]";
-    } else if (Array.isArray(value)) {
+    } else if ((0, import_primordials.ArrayIsArray)(value)) {
       result[key] = value.join(", ");
     } else if (value !== void 0 && value !== null) {
       result[key] = String(value);

package/dist/ipc-cli.js

@@ -23,6 +23,7 @@ __export(ipc_cli_exports, {
   getIpc: () => getIpc
 });
 module.exports = __toCommonJS(ipc_cli_exports);
+var import_primordials = require("./primordials");
 let _ipcObject;
 async function getIpc(key) {
   if (_ipcObject === void 0) {
@@ -49,7 +50,7 @@ async function getIpc(key) {
     if (env["SOCKET_CLI_SHADOW_SILENT"]) {
       _ipcObject.SOCKET_CLI_SHADOW_SILENT = env["SOCKET_CLI_SHADOW_SILENT"] === "true" || env["SOCKET_CLI_SHADOW_SILENT"] === "1";
     }
-    Object.freeze(_ipcObject);
+    (0, import_primordials.ObjectFreeze)(_ipcObject);
   }
   return key ? _ipcObject[key] : _ipcObject;
 }

package/dist/ipc.js

@@ -38,6 +38,7 @@ var import_node_process = __toESM(require("node:process"));
 var import_typebox = require("./external/@sinclair/typebox");
 var import_socket = require("./paths/socket");
 var import_parse = require("./schema/parse");
+var import_primordials = require("./primordials");
 const IpcStubSchema = import_typebox.Type.Object({
   /** Process ID that created the stub. */
   pid: import_typebox.Type.Integer({ minimum: 1 }),
@@ -58,12 +59,12 @@ async function ensureIpcDirectory(filePath) {
   }
   const stats = await fs.promises.lstat(dir);
   if (!stats.isDirectory()) {
-    throw new Error(`IPC path is not a directory: ${dir}`);
+    throw new import_primordials.ErrorCtor(`IPC path is not a directory: ${dir}`);
   }
   const getuid = import_node_process.default.getuid;
   const ownUid = typeof getuid === "function" ? getuid.call(import_node_process.default) : -1;
   if (ownUid !== -1 && stats.uid !== ownUid) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `IPC directory ${dir} is owned by another user (uid ${stats.uid}); refusing to use it.`
     );
   }
@@ -98,7 +99,7 @@ async function writeIpcStub(appName, data) {
   const ipcData = {
     data,
     pid: import_node_process.default.pid,
-    timestamp: Date.now()
+    timestamp: (0, import_primordials.DateNow)()
   };
   const validated = (0, import_parse.parseSchema)(IpcStubSchema, ipcData);
   const fs = /* @__PURE__ */ getFs();
@@ -116,7 +117,7 @@ async function writeIpcStub(appName, data) {
     }
   }
   try {
-    await handle.writeFile(JSON.stringify(validated, null, 2), "utf8");
+    await handle.writeFile((0, import_primordials.JSONStringify)(validated, null, 2), "utf8");
   } finally {
     await handle.close();
   }

package/dist/json/edit.js

@@ -36,6 +36,7 @@ module.exports = __toCommonJS(edit_exports);
 var import_node_process = __toESM(require("node:process"));
 var import_promises = require("node:timers/promises");
 var import_errors = require("../errors");
+var import_primordials = require("../primordials");
 var import_format = require("./format");
 const identSymbol = import_format.INDENT_SYMBOL;
 const newlineSymbol = import_format.NEWLINE_SYMBOL;
@@ -68,7 +69,7 @@ async function readFile(filepath) {
       await (0, import_promises.setTimeout)(delay);
     }
   }
-  throw new Error("Unreachable code");
+  throw new import_primordials.ErrorCtor("Unreachable code");
 }
 async function retryWrite(filepath, content, retries = 3, baseDelay = 10) {
   const fs = /* @__PURE__ */ getFs();
@@ -190,7 +191,7 @@ function getEditableJsonClass() {
       }
       async save(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No file path to save to");
+          throw new import_primordials.ErrorCtor("No file path to save to");
         }
         if (!(0, import_format.shouldSave)(
           this.content,
@@ -215,7 +216,7 @@ function getEditableJsonClass() {
       }
       saveSync(options) {
         if (!this._canSave || this.content === void 0) {
-          throw new Error("No file path to save to");
+          throw new import_primordials.ErrorCtor("No file path to save to");
         }
         if (!(0, import_format.shouldSave)(
           this.content,

package/dist/json/format.js

@@ -33,6 +33,7 @@ __export(format_exports, {
   stripFormattingSymbols: () => stripFormattingSymbols
 });
 module.exports = __toCommonJS(format_exports);
+var import_primordials = require("../primordials");
 const INDENT_SYMBOL = Symbol.for("indent");
 const NEWLINE_SYMBOL = Symbol.for("newline");
 function detectIndent(json) {
@@ -85,7 +86,7 @@ function shouldSave(currentContent, originalContent, originalFileContent, option
 }
 function sortKeys(obj) {
   const sorted = { __proto__: null };
-  const keys = Object.keys(obj).sort();
+  const keys = (0, import_primordials.ObjectKeys)(obj).sort();
   for (const key of keys) {
     sorted[key] = obj[key];
   }
@@ -95,7 +96,7 @@ function stringifyWithFormatting(content, formatting) {
   const { indent, newline } = formatting;
   const format = indent === void 0 || indent === null ? "  " : indent;
   const eol = newline === void 0 || newline === null ? "\n" : newline;
-  return `${JSON.stringify(content, void 0, format)}
+  return `${(0, import_primordials.JSONStringify)(content, void 0, format)}
 `.replace(/\n/g, eol);
 }
 function stripFormattingSymbols(content) {

package/dist/json/parse.js

@@ -27,6 +27,7 @@ __export(parse_exports, {
 module.exports = __toCommonJS(parse_exports);
 var import_validate = require("../schema/validate");
 var import_strings = require("../strings");
+var import_primordials = require("../primordials");
 const JSONParse = JSON.parse;
 // @__NO_SIDE_EFFECTS__
 function isBuffer(x) {
@@ -71,10 +72,10 @@ function jsonParse(content, options) {
   }
   return void 0;
 }
-const DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const DANGEROUS_KEYS = new import_primordials.SetCtor(["__proto__", "constructor", "prototype"]);
 function prototypePollutionReviver(key, value) {
   if (DANGEROUS_KEYS.has(key)) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       "JSON contains potentially malicious prototype pollution keys"
     );
   }
@@ -84,9 +85,9 @@ const DEFAULT_MAX_SIZE = 10 * 1024 * 1024;
 // @__NO_SIDE_EFFECTS__
 function safeJsonParse(jsonString, schema, options = {}) {
   const { allowPrototype = false, maxSize = DEFAULT_MAX_SIZE } = options;
-  const byteLength = Buffer.byteLength(jsonString, "utf8");
+  const byteLength = (0, import_primordials.BufferByteLength)(jsonString, "utf8");
   if (byteLength > maxSize) {
-    throw new Error(
+    throw new import_primordials.ErrorCtor(
       `JSON string exceeds maximum size limit${maxSize !== DEFAULT_MAX_SIZE ? ` of ${maxSize} bytes` : ""}`
     );
   }
@@ -94,13 +95,13 @@ function safeJsonParse(jsonString, schema, options = {}) {
   try {
     parsed = allowPrototype ? JSONParse(jsonString) : JSONParse(jsonString, prototypePollutionReviver);
   } catch (e) {
-    throw new Error(`Failed to parse JSON: ${e}`);
+    throw new import_primordials.ErrorCtor(`Failed to parse JSON: ${e}`);
   }
   if (schema) {
     const result = (0, import_validate.validateSchema)(schema, parsed);
     if (!result.ok) {
       const summary = result.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join(", ");
-      throw new Error(`Validation failed: ${summary}`);
+      throw new import_primordials.ErrorCtor(`Validation failed: ${summary}`);
     }
     return result.value;
   }

package/dist/links.js

@@ -38,6 +38,7 @@ var import_yoctocolors_cjs = __toESM(require("./external/yoctocolors-cjs"));
 var import_context = require("./themes/context");
 var import_themes = require("./themes/themes");
 var import_utils = require("./themes/utils");
+var import_primordials = require("./primordials");
 function link(text, url, options) {
   const opts = { __proto__: null, fallback: false, ...options };
   const theme = typeof opts.theme === "string" ? import_themes.THEMES[opts.theme] : opts.theme ?? (0, import_context.getTheme)();
@@ -47,7 +48,7 @@ function link(text, url, options) {
   if (typeof linkColor === "string" && linkColor !== "inherit") {
     const colorMethod = colors[linkColor];
     colored = colorMethod ? colorMethod(text) : colors.cyan(text);
-  } else if (Array.isArray(linkColor)) {
+  } else if ((0, import_primordials.ArrayIsArray)(linkColor)) {
     colored = colors.cyan(text);
   } else {
     colored = colors.cyan(text);

package/dist/logger.js

@@ -94,7 +94,7 @@ const LOG_SYMBOLS = /* @__PURE__ */ (() => {
     }
     updateSymbols();
   };
-  for (const trapName of Reflect.ownKeys(Reflect)) {
+  for (const trapName of (0, import_primordials.ReflectOwnKeys)(Reflect)) {
     const fn = Reflect[trapName];
     if (typeof fn === "function") {
       ;
@@ -107,7 +107,7 @@ const LOG_SYMBOLS = /* @__PURE__ */ (() => {
   (0, import_context.onThemeChange)(() => {
     reset();
   });
-  return new Proxy(target, handler);
+  return new import_primordials.ProxyCtor(target, handler);
 })();
 const boundConsoleEntries = [
   // Add bound properties from console[kBindProperties](ignoreErrors, colorMode, groupIndentation).
@@ -146,8 +146,8 @@ const consolePropAttributes = {
   configurable: true
 };
 const maxIndentation = 1e3;
-const privateConsole = /* @__PURE__ */ new WeakMap();
-const privateConstructorArgs = /* @__PURE__ */ new WeakMap();
+const privateConsole = new import_primordials.WeakMapCtor();
+const privateConstructorArgs = new import_primordials.WeakMapCtor();
 const incLogCallCountSymbol = Symbol.for("logger.logCallCount++");
 const lastWasBlankSymbol = Symbol.for("logger.lastWasBlank");
 class Logger {
@@ -220,11 +220,14 @@ class Logger {
    */
   #apply(methodName, args, stream) {
     const con = this.#getConsole();
-    const text = args.at(0);
+    const text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
     const hasText = typeof text === "string";
     const targetStream = stream || (methodName === "log" ? "stdout" : "stderr");
     const indent = this.#getIndent(targetStream);
-    const logArgs = hasText ? [(0, import_strings.applyLinePrefix)(text, { prefix: indent }), ...args.slice(1)] : args;
+    const logArgs = hasText ? [
+      (0, import_strings.applyLinePrefix)(text, { prefix: indent }),
+      ...(0, import_primordials.ArrayPrototypeSlice)(args, 1)
+    ] : args;
     (0, import_primordials.ReflectApply)(
       con[methodName],
       con,
@@ -350,7 +353,11 @@ class Logger {
    * @private
    */
   #stripSymbols(text) {
-    return text.replace(/^(?:[✖✗×⚠‼✔✓√ℹ→∴↻]|:.)[\uFE0F\s]*/u, "");
+    return (0, import_primordials.StringPrototypeReplace)(
+      text,
+      /^(?:[✖✗×⚠‼✔✓√ℹ→∴↻]|:.)[\uFE0F\s]*/u,
+      ""
+    );
   }
   /**
    * Apply a method with a symbol prefix.
@@ -358,11 +365,11 @@ class Logger {
    */
   #symbolApply(symbolType, args) {
     const con = this.#getConsole();
-    let text = args.at(0);
+    let text = (0, import_primordials.ArrayPrototypeAt)(args, 0);
     let extras;
     if (typeof text === "string") {
       text = this.#stripSymbols(text);
-      extras = args.slice(1);
+      extras = (0, import_primordials.ArrayPrototypeSlice)(args, 1);
     } else {
       extras = args;
       text = "";
@@ -587,7 +594,7 @@ class Logger {
    */
   clearVisible() {
     if (this.#boundStream) {
-      throw new Error(
+      throw new import_primordials.ErrorCtor(
         "clearVisible() is only available on the main logger instance, not on stream-bound instances"
       );
     }
@@ -932,7 +939,7 @@ class Logger {
    * ```
    */
   indent(spaces = 2) {
-    const spacesToAdd = " ".repeat(Math.min(spaces, maxIndentation));
+    const spacesToAdd = " ".repeat((0, import_primordials.MathMin)(spaces, maxIndentation));
     if (this.#boundStream) {
       const current = this.#getIndent(this.#boundStream);
       this.#setIndent(this.#boundStream, current + spacesToAdd);
@@ -1423,7 +1430,7 @@ function ensurePrototypeInitialized() {
       }
     ]
   ];
-  for (const { 0: key, 1: value } of Object.entries(globalConsole)) {
+  for (const { 0: key, 1: value } of (0, import_primordials.ObjectEntries)(globalConsole)) {
     if (!Logger.prototype[key] && typeof value === "function") {
       const { [key]: func } = {
         [key](...args) {
@@ -1457,11 +1464,11 @@ function ensurePrototypeInitialized() {
       ]);
     }
   }
-  Object.defineProperties(Logger.prototype, Object.fromEntries(entries));
+  (0, import_primordials.ObjectDefineProperties)(Logger.prototype, Object.fromEntries(entries));
 }
 function getConsoleSymbols() {
   if (_consoleSymbols === void 0) {
-    _consoleSymbols = Object.getOwnPropertySymbols(globalConsole);
+    _consoleSymbols = (0, import_primordials.ObjectGetOwnPropertySymbols)(globalConsole);
   }
   return _consoleSymbols;
 }

package/dist/memoization.js

@@ -29,9 +29,10 @@ __export(memoization_exports, {
 });
 module.exports = __toCommonJS(memoization_exports);
 var import_debug = require("./debug");
+var import_primordials = require("./primordials");
 const cacheRegistry = [];
 function defaultKeyGen(args) {
-  return JSON.stringify(args, (_key, value) => {
+  return (0, import_primordials.JSONStringify)(args, (_key, value) => {
     if (value === void 0) {
       return "\0undefined";
     }
@@ -74,9 +75,9 @@ function memoize(fn, options = {}) {
     ttl = Number.POSITIVE_INFINITY
   } = options;
   if (ttl < 0) {
-    throw new TypeError("TTL must be non-negative");
+    throw new import_primordials.TypeErrorCtor("TTL must be non-negative");
   }
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new import_primordials.MapCtor();
   cacheRegistry.push(() => {
     cache.clear();
   });
@@ -96,7 +97,7 @@ function memoize(fn, options = {}) {
     if (ttl === Number.POSITIVE_INFINITY) {
       return false;
     }
-    return Date.now() - entry.timestamp > ttl;
+    return (0, import_primordials.DateNow)() - entry.timestamp > ttl;
   }
   return function memoized(...args) {
     const key = keyGen(...args);
@@ -130,7 +131,7 @@ function memoizeAsync(fn, options = {}) {
     name = fn.name || "anonymous",
     ttl = Number.POSITIVE_INFINITY
   } = options;
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new import_primordials.MapCtor();
   cacheRegistry.push(() => {
     cache.clear();
   });
@@ -150,13 +151,13 @@ function memoizeAsync(fn, options = {}) {
     if (ttl === Number.POSITIVE_INFINITY) {
       return false;
     }
-    return Date.now() - entry.timestamp > ttl;
+    return (0, import_primordials.DateNow)() - entry.timestamp > ttl;
   }
   function bumpRecency(key, entry) {
     cache.delete(key);
     cache.set(key, entry);
   }
-  const refreshing = /* @__PURE__ */ new Map();
+  const refreshing = new import_primordials.MapCtor();
   return async function memoized(...args) {
     const key = keyGen(...args);
     const cached = cache.get(key);
@@ -176,23 +177,23 @@ function memoizeAsync(fn, options = {}) {
       cache.delete(key);
     }
     (0, import_debug.debugLog)(`[memoizeAsync:${name}] miss`, { key });
-    const promise = fn(...args).then(
-      (result) => {
+    const promise = (async () => {
+      try {
+        const result = await fn(...args);
         refreshing.delete(key);
         const entry = cache.get(key);
         if (entry) {
-          entry.value = Promise.resolve(result);
-          entry.timestamp = Date.now();
+          entry.value = (0, import_primordials.PromiseResolve)(result);
+          entry.timestamp = (0, import_primordials.DateNow)();
         }
         return result;
-      },
-      (error) => {
+      } catch (error) {
         refreshing.delete(key);
         cache.delete(key);
         (0, import_debug.debugLog)(`[memoizeAsync:${name}] error`, { key, error });
         throw error;
       }
-    );
+    })();
     refreshing.set(key, promise);
     evictLRU();
     cache.set(key, {
@@ -205,7 +206,7 @@ function memoizeAsync(fn, options = {}) {
   };
 }
 function memoizeWeak(fn) {
-  const cache = /* @__PURE__ */ new WeakMap();
+  const cache = new import_primordials.WeakMapCtor();
   return function memoized(key) {
     if (cache.has(key)) {
       (0, import_debug.debugLog)(`[memoizeWeak:${fn.name}] hit`);

package/dist/node/async-hooks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy-loader for `node:async_hooks`. See `node/fs.ts`
+ * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeAsyncHooks from 'node:async_hooks';
+export declare function getNodeAsyncHooks(): typeof NodeAsyncHooks;

package/dist/node/async-hooks.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 async_hooks_exports = {};
+__export(async_hooks_exports, {
+  getNodeAsyncHooks: () => getNodeAsyncHooks
+});
+module.exports = __toCommonJS(async_hooks_exports);
+let _asyncHooks;
+// @__NO_SIDE_EFFECTS__
+function getNodeAsyncHooks() {
+  return _asyncHooks ??= require("node:async_hooks");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeAsyncHooks
+});