@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/cacache/read.js

@@ -0,0 +1,51 @@
+"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 read_exports = {};
+__export(read_exports, {
+  get: () => get,
+  safeGet: () => safeGet
+});
+module.exports = __toCommonJS(read_exports);
+var import_socket = require("../paths/socket");
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+async function get(key, options) {
+  if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+    throw new import_error.TypeErrorCtor(
+      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+    );
+  }
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.get((0, import_socket.getSocketCacacheDir)(), key, options);
+}
+async function safeGet(key, options) {
+  try {
+    return await get(key, options);
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  get,
+  safeGet
+});

package/dist/cacache/tmp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file `withTmp` — run a callback with a freshly-created temp directory under
+ *   the cacache root. Wraps cacache's `tmp.withTmp` with a corrected type
+ *   signature (the DefinitelyTyped definition incorrectly declares `void` even
+ *   though the function forwards the callback's return value).
+ */
+/**
+ * Execute a callback with a temporary directory for cache operations.
+ *
+ * @example
+ *   ;```typescript
+ *   const result = await withTmp(async tmpDir => {
+ *     // Use tmpDir for temporary cache work
+ *     return 'done'
+ *   })
+ *   ```
+ */
+export declare function withTmp<T>(callback: (tmpDirPath: string) => Promise<T>): Promise<T>;

package/dist/cacache/tmp.js

@@ -0,0 +1,39 @@
+"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 tmp_exports = {};
+__export(tmp_exports, {
+  withTmp: () => withTmp
+});
+module.exports = __toCommonJS(tmp_exports);
+var import_socket = require("../paths/socket");
+var import_internal = require("./_internal");
+async function withTmp(callback) {
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.tmp.withTmp(
+    (0, import_socket.getSocketCacacheDir)(),
+    {},
+    callback
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withTmp
+});

package/dist/cacache/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Public type surface for `cacache/*` modules — the `CacheEntry` row
+ *   shape returned by reads and the option bags consumed by `clear` / `get` /
+ *   `put`. Pure types, no runtime side effects.
+ */
+export interface GetOptions {
+    integrity?: string | undefined;
+    size?: number | undefined;
+    memoize?: boolean | undefined;
+}
+export interface PutOptions {
+    integrity?: string | undefined;
+    size?: number | undefined;
+    metadata?: unknown | undefined;
+    memoize?: boolean | undefined;
+}
+export interface CacheEntry {
+    data: Buffer;
+    integrity: string;
+    key: string;
+    metadata?: unknown | undefined;
+    path: string;
+    size: number;
+    time: number;
+}
+export interface RemoveOptions {
+    /**
+     * Optional key prefix to filter removals. If provided, only keys starting
+     * with this prefix will be removed. Can include wildcards (*) for pattern
+     * matching.
+     *
+     * @example
+     *   { prefix: 'socket-sdk' } // Simple prefix
+     *   { prefix: 'socket-sdk:scans:abc*' } // With wildcard
+     */
+    prefix?: string | undefined;
+}

package/dist/cacache/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/cacache/write.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Cache write entrypoints — `put` (insert/replace by key) and `remove`
+ *   (single-key delete). Both reject wildcards; for pattern deletes use
+ *   `clear({ prefix: 'foo*' })`.
+ */
+import type { PutOptions } from './types';
+/**
+ * Put data into the Socket shared cache with a key.
+ *
+ * @example
+ *   ;```typescript
+ *   await put('socket-sdk:scans:abc123', Buffer.from('result data'))
+ *   ```
+ *
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function put(key: string, data: string | Buffer, options?: PutOptions | undefined): Promise<{
+    integrity: string;
+    size: number;
+}>;
+/**
+ * Remove an entry from the Socket shared cache by key.
+ *
+ * @example
+ *   ;```typescript
+ *   await remove('socket-sdk:scans:abc123')
+ *   ```
+ *
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function remove(key: string): Promise<unknown>;

package/dist/cacache/write.js

@@ -0,0 +1,53 @@
+"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 write_exports = {};
+__export(write_exports, {
+  put: () => put,
+  remove: () => remove
+});
+module.exports = __toCommonJS(write_exports);
+var import_socket = require("../paths/socket");
+var import_error = require("../primordials/error");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+async function put(key, data, options) {
+  if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+    throw new import_error.TypeErrorCtor(
+      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+    );
+  }
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.put((0, import_socket.getSocketCacacheDir)(), key, data, options);
+}
+async function remove(key) {
+  if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+    throw new import_error.TypeErrorCtor(
+      'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
+    );
+  }
+  const cacache = (0, import_internal.getCacache)();
+  return await cacache.rm.entry((0, import_socket.getSocketCacacheDir)(), key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  put,
+  remove
+});

package/dist/cache/ttl/store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file `createTtlCache` — generic TTL-based cache built on top of cacache
+ *   (persistent) plus an in-memory LRU memo layer. Two-tier caching: hot data
+ *   lives in `memoCache` (Map<string, TtlCacheEntry>) capped at `memoMaxSize`
+ *   entries with LRU eviction via Map insertion-order semantics. Persistent
+ *   storage uses cacache so cached values survive process restarts. Key
+ *   features:
+ *
+ *   - Per-key namespacing via `prefix` so multiple caches share one cacache
+ *     directory without conflicting.
+ *   - `getOrFetch` deduplicates concurrent requests for the same key
+ *     (thundering-herd protection via `inflightRequests` map).
+ *   - Wildcard support for `getAll` / `deleteAll` (single-key methods throw on
+ *     `*`).
+ *   - Clock-skew detection: entries with suspiciously-far-future `expiresAt` are
+ *     treated as expired.
+ */
+import type { TtlCache, TtlCacheOptions } from './types';
+/**
+ * Create a TTL-based cache instance.
+ *
+ * @example
+ *   ;```typescript
+ *   const cache = createTtlCache({ ttl: 60_000, prefix: 'my-app' })
+ *   await cache.set('key', { value: 42 })
+ *   const data = await cache.get('key') // { value: 42 }
+ *   ```
+ */
+export declare function createTtlCache(options?: TtlCacheOptions): TtlCache;

package/dist/{cache-with-ttl.js → cache/ttl/store.js}

@@ -28,13 +28,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cache_with_ttl_exports = {};
-__export(cache_with_ttl_exports, {
+var store_exports = {};
+__export(store_exports, {
   createTtlCache: () => createTtlCache
 });
-module.exports = __toCommonJS(cache_with_ttl_exports);
-var cacache = __toESM(require("./cacache"));
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(store_exports);
+var import_clear = require("../../cacache/clear");
+var import_read = require("../../cacache/read");
+var import_write = require("../../cacache/write");
+var import_date = require("../../primordials/date");
+var import_error = require("../../primordials/error");
+var import_json = require("../../primordials/json");
+var import_map_set = require("../../primordials/map-set");
+var import_math = require("../../primordials/math");
+var import_regexp = require("../../primordials/regexp");
+var import_string = require("../../primordials/string");
 const DEFAULT_TTL_MS = 5 * 60 * 1e3;
 const DEFAULT_PREFIX = "ttl-cache";
 const DEFAULT_MEMO_MAX_SIZE = 1e3;
@@ -48,12 +56,12 @@ function createTtlCache(options) {
     ...options
   };
   if (opts.prefix?.includes("*")) {
-    throw new import_primordials.TypeErrorCtor(
+    throw new import_error.TypeErrorCtor(
       'Cache prefix cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) for wildcard matching.'
     );
   }
-  const memoCache = new import_primordials.MapCtor();
-  const memoMaxSize = (0, import_primordials.MathMax)(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
+  const memoCache = new import_map_set.MapCtor();
+  const memoMaxSize = (0, import_math.MathMax)(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
   function memoSet(fullKey, entry) {
     if (memoCache.has(fullKey)) {
       memoCache.delete(fullKey);
@@ -70,7 +78,7 @@ function createTtlCache(options) {
     return `${opts.prefix}:${key}`;
   }
   function isExpired(entry) {
-    const now = (0, import_primordials.DateNow)();
+    const now = (0, import_date.DateNow)();
     const maxFutureMs = 1e4;
     if (entry.expiresAt > now + ttl + maxFutureMs) {
       return true;
@@ -81,20 +89,20 @@ function createTtlCache(options) {
     const fullPattern = buildKey(pattern);
     const hasWildcard = pattern.includes("*");
     if (!hasWildcard) {
-      return (key) => (0, import_primordials.StringPrototypeStartsWith)(key, fullPattern);
+      return (key) => (0, import_string.StringPrototypeStartsWith)(key, fullPattern);
     }
-    const escaped = (0, import_primordials.StringPrototypeReplaceAll)(
+    const escaped = (0, import_string.StringPrototypeReplaceAll)(
       fullPattern,
       /[.+?^${}()|[\]\\]/g,
       "\\$&"
     );
-    const regexPattern = (0, import_primordials.StringPrototypeReplaceAll)(escaped, "*", ".*");
-    const regex = new import_primordials.RegExpCtor(`^${regexPattern}$`);
-    return (key) => (0, import_primordials.RegExpPrototypeTest)(regex, key);
+    const regexPattern = (0, import_string.StringPrototypeReplaceAll)(escaped, "*", ".*");
+    const regex = new import_regexp.RegExpCtor(`^${regexPattern}$`);
+    return (key) => (0, import_regexp.RegExpPrototypeTest)(regex, key);
   }
   async function get(key) {
-    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-      throw new import_primordials.TypeErrorCtor(
+    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+      throw new import_error.TypeErrorCtor(
         "Cache key cannot contain wildcards (*). Use getAll(pattern) to retrieve multiple entries."
       );
     }
@@ -109,14 +117,14 @@ function createTtlCache(options) {
         memoCache.delete(fullKey);
       }
     }
-    const cacheEntry = await cacache.safeGet(fullKey);
+    const cacheEntry = await (0, import_read.safeGet)(fullKey);
     if (cacheEntry) {
       let entry;
       try {
-        entry = (0, import_primordials.JSONParse)(cacheEntry.data.toString("utf8"));
+        entry = (0, import_json.JSONParse)(cacheEntry.data.toString("utf8"));
       } catch {
         try {
-          await cacache.remove(fullKey);
+          await (0, import_write.remove)(fullKey);
         } catch {
         }
         return void 0;
@@ -128,14 +136,14 @@ function createTtlCache(options) {
         return entry.data;
       }
       try {
-        await cacache.remove(fullKey);
+        await (0, import_write.remove)(fullKey);
       } catch {
       }
     }
     return void 0;
   }
   async function getAll(pattern) {
-    const results = new import_primordials.MapCtor();
+    const results = new import_map_set.MapCtor();
     const matches = createMatcher(pattern);
     if (opts.memoize) {
       for (const [key, entry] of memoCache.entries()) {
@@ -146,12 +154,12 @@ function createTtlCache(options) {
           memoCache.delete(key);
           continue;
         }
-        const originalKey = opts.prefix ? (0, import_primordials.StringPrototypeSlice)(key, opts.prefix.length + 1) : key;
+        const originalKey = opts.prefix ? (0, import_string.StringPrototypeSlice)(key, opts.prefix.length + 1) : key;
         results.set(originalKey, entry.data);
       }
     }
-    const cacheDir = (await import("./paths/socket")).getSocketCacacheDir();
-    const cacacheModule = await import("./cacache");
+    const cacheDir = (await import("../../paths/socket")).getSocketCacacheDir();
+    const cacacheModule = await import("../../cacache/_internal");
     const stream = cacacheModule.getCacache().ls.stream(cacheDir);
     for await (const cacheEntry of stream) {
       if (!cacheEntry.key.startsWith(`${opts.prefix}:`)) {
@@ -165,15 +173,15 @@ function createTtlCache(options) {
         continue;
       }
       try {
-        const entry = await cacache.safeGet(cacheEntry.key);
+        const entry = await (0, import_read.safeGet)(cacheEntry.key);
         if (!entry) {
           continue;
         }
-        const parsed = (0, import_primordials.JSONParse)(
+        const parsed = (0, import_json.JSONParse)(
           entry.data.toString("utf8")
         );
         if (isExpired(parsed)) {
-          await cacache.remove(cacheEntry.key);
+          await (0, import_write.remove)(cacheEntry.key);
           continue;
         }
         results.set(originalKey, parsed.data);
@@ -186,27 +194,27 @@ function createTtlCache(options) {
     return results;
   }
   async function set(key, data) {
-    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-      throw new import_primordials.TypeErrorCtor(
+    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+      throw new import_error.TypeErrorCtor(
         'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
       );
     }
     const fullKey = buildKey(key);
     const entry = {
       data,
-      expiresAt: (0, import_primordials.DateNow)() + ttl
+      expiresAt: (0, import_date.DateNow)() + ttl
     };
     if (opts.memoize) {
       memoSet(fullKey, entry);
     }
     try {
-      await cacache.put(fullKey, JSON.stringify(entry), {
+      await (0, import_write.put)(fullKey, (0, import_json.JSONStringify)(entry), {
         metadata: { expiresAt: entry.expiresAt }
       });
     } catch {
     }
   }
-  const inflightRequests = new import_primordials.MapCtor();
+  const inflightRequests = new import_map_set.MapCtor();
   async function getOrFetch(key, fetcher) {
     const fullKey = buildKey(key);
     const preexisting = inflightRequests.get(fullKey);
@@ -234,20 +242,20 @@ function createTtlCache(options) {
     return await promise;
   }
   async function deleteEntry(key) {
-    if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-      throw new import_primordials.TypeErrorCtor(
+    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
+      throw new import_error.TypeErrorCtor(
         "Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries."
       );
     }
     const fullKey = buildKey(key);
     memoCache.delete(fullKey);
     try {
-      await cacache.remove(fullKey);
+      await (0, import_write.remove)(fullKey);
     } catch {
     }
   }
   async function deleteAll(pattern) {
-    const fullPrefix = pattern ? `${opts.prefix}:${pattern}` : opts.prefix;
+    const fullPrefix = pattern ? `${opts.prefix}:${pattern}` : `${opts.prefix}:`;
     if (!pattern) {
       memoCache.clear();
     } else {
@@ -258,7 +266,7 @@ function createTtlCache(options) {
         }
       }
     }
-    const removed = await cacache.clear({ prefix: fullPrefix });
+    const removed = await (0, import_clear.clear)({ prefix: fullPrefix });
     return removed ?? 0;
   }
   async function clear(options2) {

package/dist/cache/ttl/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @file Public type surface for `cache/ttl/*` modules — the `TtlCache`
+ *   interface (the seven-method API returned by `createTtlCache`), the
+ *   `TtlCacheEntry` storage shape, and the `TtlCacheOptions` / `ClearOptions`
+ *   configuration records. Pure types, no runtime side effects.
+ */
+export interface ClearOptions {
+    /**
+     * Only clear in-memory memoization cache, not persistent cache. Useful for
+     * forcing a refresh of cached data without removing it from disk.
+     *
+     * @default false
+     */
+    memoOnly?: boolean | undefined;
+}
+export interface TtlCache {
+    /**
+     * Get cached data without fetching. Returns undefined if not found or
+     * expired.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     *
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    get<T>(key: string): Promise<T | undefined>;
+    /**
+     * Get all cached entries matching a pattern. Supports wildcards (*) for
+     * flexible matching.
+     *
+     * @param pattern - Key pattern (supports * wildcards, or use '*' for all
+     *   entries)
+     *
+     * @returns Map of matching entries (key -> value)
+     */
+    getAll<T>(pattern: string): Promise<Map<string, T>>;
+    /**
+     * Get cached data or fetch and cache if missing/expired.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     */
+    getOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
+    /**
+     * Set cached data with TTL.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     *
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    set<T>(key: string, data: T): Promise<void>;
+    /**
+     * Delete a specific cache entry.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     *
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete all cache entries matching a pattern. Supports wildcards (*) for
+     * flexible matching.
+     *
+     * @param pattern - Key pattern (supports * wildcards, or omit to delete all)
+     *
+     * @returns Number of entries deleted
+     */
+    deleteAll(pattern?: string | undefined): Promise<number>;
+    /**
+     * Clear all cache entries (like Map.clear()). Optionally clear only in-memory
+     * cache.
+     *
+     * @param options - Optional configuration.
+     */
+    clear(options?: ClearOptions | undefined): Promise<void>;
+}
+export interface TtlCacheEntry<T> {
+    data: T;
+    expiresAt: number;
+}
+export interface TtlCacheOptions {
+    /**
+     * Time-to-live in milliseconds.
+     *
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    ttl?: number | undefined;
+    /**
+     * Enable in-memory memoization for hot data.
+     *
+     * @default true
+     */
+    memoize?: boolean | undefined;
+    /**
+     * Maximum number of entries to keep in the in-memory memo cache. When
+     * exceeded, the least-recently-used entry is evicted. The persistent
+     * (cacache) layer is unaffected.
+     *
+     * @default 1000
+     */
+    memoMaxSize?: number | undefined;
+    /**
+     * Custom cache key prefix. Must not contain wildcards (_). Use clear({
+     * prefix: "pattern_" }) for wildcard matching instead.
+     *
+     * @default 'ttl-cache'
+     *
+     * @throws {TypeError} If prefix contains wildcards
+     */
+    prefix?: string | undefined;
+}

package/dist/cache/ttl/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/checks/primordials-defaults.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file GENERATED — do not edit by hand. Run `node
+ *   scripts/fix/generate-primordials-defaults.mts` (also runs as part of `pnpm
+ *   run build`) to regenerate from the `globals` npm package's globals.json
+ *   crossed against src/primordials/*.ts `Ctor` exports. Source:
+ *   globals@<bumped via taze>, env = builtin ∪ node. Filter: identifiers
+ *   socket-lib exports as `<name>Ctor`.
+ */
+/**
+ * Fleet-canonical alias map: socket-lib mirrors standard JS + Node globals with
+ * a `Ctor` suffix. Downstream repos that destructure raw `primordials` use this
+ * map to resolve the source-side name to socket-lib's export.
+ */
+export declare const DEFAULT_ALIAS_MAP: Readonly<Record<string, string>>;
+/**
+ * Names that exist in Node's internal `primordials` but are intentionally NOT
+ * mirrored to socket-lib (mostly Safe* wrappers and prototype-method aliases).
+ * Adding to this set is a per-name decision; the list is hand-maintained.
+ */
+export declare const DEFAULT_NODE_INTERNAL_ONLY: readonly string[];