@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/arrays/chunk.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Split an array into fixed-size chunks. The last chunk holds the
+ *   leftover when length is not evenly divisible.
+ */
+/**
+ * Split an array into chunks of a specified size.
+ *
+ * Divides an array into smaller arrays of the specified chunk size. The last
+ * chunk may contain fewer elements if the array length is not evenly divisible
+ * by the chunk size.
+ *
+ * @example
+ *   ;```ts
+ *   // Split into pairs (default)
+ *   arrayChunk([1, 2, 3, 4, 5])
+ *   // Returns: [[1, 2], [3, 4], [5]]
+ *
+ *   // Split into groups of 3
+ *   arrayChunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3)
+ *   // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ *
+ *   // Works with readonly arrays
+ *   const readonlyArr = [1, 2, 3] as const
+ *   arrayChunk(readonlyArr)
+ *   // Returns: [[1, 2], [3]]
+ *   ```
+ *
+ * @default 2
+ *
+ * @param arr - The array to split into chunks (can be readonly)
+ * @param size - Size of each chunk. Must be greater than 0.
+ *
+ * @returns Array of chunks, where each chunk is an array of elements
+ *
+ * @throws {Error} If chunk size is less than or equal to 0
+ */
+export declare function arrayChunk<T>(arr: T[] | readonly T[], size?: number | undefined): T[][];

package/dist/arrays/chunk.js

@@ -0,0 +1,43 @@
+"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 chunk_exports = {};
+__export(chunk_exports, {
+  arrayChunk: () => arrayChunk
+});
+module.exports = __toCommonJS(chunk_exports);
+var import_error = require("../primordials/error");
+// @__NO_SIDE_EFFECTS__
+function arrayChunk(arr, size) {
+  const chunkSize = size ?? 2;
+  if (chunkSize <= 0) {
+    throw new import_error.ErrorCtor("Chunk size must be greater than 0");
+  }
+  const { length } = arr;
+  const chunks = [];
+  for (let i = 0; i < length; i += chunkSize) {
+    chunks.push(arr.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayChunk
+});

package/dist/arrays/join.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @file Grammatical list joiners via `Intl.ListFormat` — Oxford-comma aware and
+ *   locale-correct. `joinAnd` ("a, b, and c"), `joinOr` ("a, b, or c").
+ */
+/**
+ * Join array elements with proper "and" conjunction formatting.
+ *
+ * Formats an array of strings into a grammatically correct list using "and" as
+ * the conjunction. Uses `Intl.ListFormat` for proper English formatting with
+ * Oxford comma support.
+ *
+ * @example
+ *   ```ts
+ *   // Two items
+ *   joinAnd(['apples', 'oranges'])
+ *   // Returns: "apples and oranges"
+ *
+ *   // Three or more items (Oxford comma)
+ *   joinAnd(['apples', 'oranges', 'bananas'])
+ *   // Returns: "apples, oranges, and bananas"
+ *
+ *   // Single item
+ *   joinAnd(['apples'])
+ *   // Returns: "apples"
+ *
+ *   // Empty array
+ *   joinAnd([])
+ *   // Returns: ""
+ *
+ *   // Usage in messages
+ *   const items = ['React', 'Vue', 'Angular']
+ *   console.log(`You can choose ${joinAnd(items)}`)
+ *   // Outputs: "You can choose React, Vue, and Angular"
+ *   ```
+ *
+ * @param arr - Array of strings to join (can be readonly)
+ *
+ * @returns Formatted string with proper "and" conjunction
+ */
+export declare function joinAnd(arr: string[] | readonly string[]): string;
+/**
+ * Join array elements with proper "or" disjunction formatting.
+ *
+ * Formats an array of strings into a grammatically correct list using "or" as
+ * the disjunction. Uses `Intl.ListFormat` for proper English formatting with
+ * Oxford comma support.
+ *
+ * @example
+ *   ```ts
+ *   // Two items
+ *   joinOr(['yes', 'no'])
+ *   // Returns: "yes or no"
+ *
+ *   // Three or more items (Oxford comma)
+ *   joinOr(['red', 'green', 'blue'])
+ *   // Returns: "red, green, or blue"
+ *
+ *   // Single item
+ *   joinOr(['maybe'])
+ *   // Returns: "maybe"
+ *
+ *   // Empty array
+ *   joinOr([])
+ *   // Returns: ""
+ *
+ *   // Usage in prompts
+ *   const options = ['npm', 'yarn', 'pnpm']
+ *   console.log(`Choose a package manager: ${joinOr(options)}`)
+ *   // Outputs: "Choose a package manager: npm, yarn, or pnpm"
+ *   ```
+ *
+ * @param arr - Array of strings to join (can be readonly)
+ *
+ * @returns Formatted string with proper "or" disjunction
+ */
+export declare function joinOr(arr: string[] | readonly string[]): string;

package/dist/{env/helpers.js → arrays/join.js}

@@ -18,29 +18,23 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var helpers_exports = {};
-__export(helpers_exports, {
-  envAsBoolean: () => envAsBoolean,
-  envAsNumber: () => envAsNumber,
-  envAsString: () => envAsString
+var join_exports = {};
+__export(join_exports, {
+  joinAnd: () => joinAnd,
+  joinOr: () => joinOr
 });
-module.exports = __toCommonJS(helpers_exports);
-var import_env = require("../env");
+module.exports = __toCommonJS(join_exports);
+var import_internal = require("./_internal");
 // @__NO_SIDE_EFFECTS__
-function envAsBoolean(value) {
-  return (0, import_env.envAsBoolean)(value, { trim: false });
+function joinAnd(arr) {
+  return (0, import_internal.getConjunctionFormatter)().format(arr);
 }
 // @__NO_SIDE_EFFECTS__
-function envAsNumber(value) {
-  return (0, import_env.envAsNumber)(value, { mode: "float", allowInfinity: true });
-}
-// @__NO_SIDE_EFFECTS__
-function envAsString(value) {
-  return (0, import_env.envAsString)(value, { trim: false });
+function joinOr(arr) {
+  return (0, import_internal.getDisjunctionFormatter)().format(arr);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  envAsBoolean,
-  envAsNumber,
-  envAsString
+  joinAnd,
+  joinOr
 });

package/dist/arrays/predicates.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file Array type-guard predicates. Currently just a re-export of native
+ *   `Array.isArray` for consistency with the rest of the arrays surface — kept
+ *   in its own leaf because it's runtime-trivial but conceptually a different
+ *   concern from `chunk` / `unique` / `join`.
+ */
+/**
+ * Alias for native Array.isArray. Determines whether the passed value is an
+ * array.
+ *
+ * This is a direct reference to the native `Array.isArray` method, providing a
+ * type guard that narrows the type to an array type. Exported for consistency
+ * with other array utilities in this module.
+ *
+ * @example
+ *   ;```ts
+ *   // Check if value is an array
+ *   isArray([1, 2, 3])
+ *   // Returns: true
+ *
+ *   isArray('not an array')
+ *   // Returns: false
+ *
+ *   isArray(null)
+ *   // Returns: false
+ *
+ *   // Type guard usage
+ *   function processValue(value: unknown) {
+ *     if (isArray(value)) {
+ *       // TypeScript knows value is an array here
+ *       console.log(value.length)
+ *     }
+ *   }
+ *   ```
+ *
+ * @param value - The value to check.
+ *
+ * @returns `true` if the value is an array, `false` otherwise
+ */
+export declare const isArray: (arg: any) => arg is any[];

package/dist/arrays/predicates.js

@@ -0,0 +1,30 @@
+"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 predicates_exports = {};
+__export(predicates_exports, {
+  isArray: () => isArray
+});
+module.exports = __toCommonJS(predicates_exports);
+const isArray = Array.isArray;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isArray
+});

package/dist/arrays/unique.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Deduplicate an array via `Set`. Preserves
+ * first-occurrence order.
+ */
+/**
+ * Get unique values from an array.
+ *
+ * Returns a new array containing only the unique values from the input array.
+ * Uses `Set` internally for efficient deduplication. Order of first occurrence
+ * is preserved.
+ *
+ * @example
+ *   ;```ts
+ *   // Remove duplicate numbers
+ *   arrayUnique([1, 2, 2, 3, 1, 4])
+ *   // Returns: [1, 2, 3, 4]
+ *
+ *   // Remove duplicate strings
+ *   arrayUnique(['apple', 'banana', 'apple', 'cherry'])
+ *   // Returns: ['apple', 'banana', 'cherry']
+ *
+ *   // Works with readonly arrays
+ *   const readonlyArr = [1, 1, 2] as const
+ *   arrayUnique(readonlyArr)
+ *   // Returns: [1, 2]
+ *
+ *   // Empty arrays return empty
+ *   arrayUnique([])
+ *   // Returns: []
+ *   ```
+ *
+ * @param arr - The array to deduplicate (can be readonly)
+ *
+ * @returns New array with duplicate values removed
+ */
+export declare function arrayUnique<T>(arr: T[] | readonly T[]): T[];

package/dist/arrays/unique.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 unique_exports = {};
+__export(unique_exports, {
+  arrayUnique: () => arrayUnique
+});
+module.exports = __toCommonJS(unique_exports);
+var import_map_set = require("../primordials/map-set");
+// @__NO_SIDE_EFFECTS__
+function arrayUnique(arr) {
+  return [...new import_map_set.SetCtor(arr)];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayUnique
+});

package/dist/bin/_internal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
+ *   and the binary-resolution caches. Underscore prefix keeps this file out of
+ *   the public exports map (see the `dist/<dir>/_<file>` ignore in
+ *   scripts/fix/generate-package-exports.mts). Two caches:
+ *
+ *   1. `binPathCache` — maps a binary name to its first resolved path. Validated
+ *      with `existsSync` before reuse so a stale cache doesn't survive a tool
+ *      reinstall mid-session.
+ *   2. `binPathAllCache` — same shape but stores all-match arrays for callers that
+ *      pass `{ all: true }`. Separate cache because the two return shapes can't
+ *      be reconciled without losing type info.
+ *   3. `voltaBinCache` — maps a `${voltaPath}:${basename}` composite key to the
+ *      resolved Volta-managed binary path. Volta resolves npm / pnpm / yarn
+ *      through a layered tools/image directory and the lookup is expensive
+ *      enough that caching is worth the memory.
+ */
+export declare const binPathCache: Map<string, string>;
+export declare const binPathAllCache: Map<string, string[]>;
+export declare const voltaBinCache: Map<string, string>;
+export { getNodeFs as getFs } from '../node/fs';
+export { getNodePath as getPath } from '../node/path';

package/dist/bin/_internal.js

@@ -0,0 +1,43 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  binPathAllCache: () => binPathAllCache,
+  binPathCache: () => binPathCache,
+  getFs: () => import_fs.getNodeFs,
+  getPath: () => import_path.getNodePath,
+  voltaBinCache: () => voltaBinCache
+});
+module.exports = __toCommonJS(internal_exports);
+var import_map_set = require("../primordials/map-set");
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
+const binPathCache = new import_map_set.MapCtor();
+const binPathAllCache = new import_map_set.MapCtor();
+const voltaBinCache = new import_map_set.MapCtor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  binPathAllCache,
+  binPathCache,
+  getFs,
+  getPath,
+  voltaBinCache
+});

package/dist/bin/check-primordials.d.ts

@@ -1,18 +1,44 @@
 /**
- * @fileoverview `socket-lib check primordials` handler.
- *
- * Loads a JSON config from disk (default
- * `primordials-coverage.config.json` at the repo root, override with
- * `--config <path>`), runs the drift check, and renders the result.
- *
- *   socket-lib check primordials
- *   socket-lib check primordials --config ./primordials.config.json
- *   socket-lib check primordials --json     # machine-readable output
- *   socket-lib check primordials --explain  # one detailed line per finding
- *   socket-lib check primordials --silent   # silent on success
- *
- * Exit codes:
- *   0 — no drift
- *   1 — drift detected (or config / lookup error)
+ * @file `socket-lib check primordials` handler. Loads a JSON config from disk
+ *   (default `primordials-coverage.config.json` at the repo root, override with
+ *   `--config <path>`), runs the drift check, and renders the result.
+ *   socket-lib check primordials socket-lib check primordials --config
+ *   ./primordials.config.json socket-lib check primordials --json #
+ *   machine-readable output socket-lib check primordials --explain # one
+ *   detailed line per finding socket-lib check primordials --silent # silent on
+ *   success Exit codes: 0 — no drift 1 — drift detected (or config / lookup
+ *   error)
  */
+import { type PrimordialsCheckConfig, type PrimordialsCheckResult, type PrimordialsFinding } from '../checks/primordials';
+interface ParsedArgs {
+    readonly config: string | undefined;
+    readonly json: boolean;
+    readonly explain: boolean;
+    readonly silent: boolean;
+    readonly help: boolean;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/**
+ * Pick the config file. Returns the explicit `--config` argument when given
+ * (even if it doesn't exist — the caller will surface the error with the path
+ * they typed). Otherwise probes the fallback list in order and returns the
+ * first hit. Returns the head of the list when none exist, so the caller's
+ * "config file not found" error message names the canonical default.
+ */
+export declare function resolveConfigPath(explicit: string | undefined): string;
+export declare function printHelp(): void;
+export declare function loadConfig(configPath: string): PrimordialsCheckConfig;
+interface SerializedFinding {
+    kind: PrimordialsFinding['kind'];
+    name: string;
+    files: readonly string[];
+    hint: string;
+}
+export declare function serialize(result: PrimordialsCheckResult): {
+    ok: boolean;
+    used: number;
+    findings: SerializedFinding[];
+};
+export declare function renderHuman(result: PrimordialsCheckResult, args: ParsedArgs): void;
 export declare function runCheckPrimordials(argv: readonly string[]): Promise<number>;
+export {};

package/dist/bin/check-primordials.js

@@ -30,17 +30,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var check_primordials_exports = {};
 __export(check_primordials_exports, {
-  runCheckPrimordials: () => runCheckPrimordials
+  loadConfig: () => loadConfig,
+  parseArgs: () => parseArgs,
+  printHelp: () => printHelp,
+  renderHuman: () => renderHuman,
+  resolveConfigPath: () => resolveConfigPath,
+  runCheckPrimordials: () => runCheckPrimordials,
+  serialize: () => serialize
 });
 module.exports = __toCommonJS(check_primordials_exports);
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"));
 var import_node_process = __toESM(require("node:process"));
-var import_errors = require("../errors");
-var import_logger = require("../logger");
+var import_message = require("../errors/message");
+var import_default = require("../logger/default");
+var import_array = require("../primordials/array");
+var import_error = require("../primordials/error");
+var import_json = require("../primordials/json");
+var import_object = require("../primordials/object");
+var import_primordials_defaults = require("../checks/primordials-defaults");
 var import_primordials = require("../checks/primordials");
 var import_parse = require("../argv/parse");
-const logger = (0, import_logger.getDefaultLogger)();
+const logger = (0, import_default.getDefaultLogger)();
 const DEFAULT_CONFIG_PATH = ".socket-lib.json";
 const FALLBACK_CONFIG_PATHS = [
   ".socket-lib.json",
@@ -99,57 +110,61 @@ function printHelp() {
   logger.log("Config (.socket-lib.json \u2014 primordials section):");
   logger.log("  {");
   logger.log('    "primordials": {');
-  logger.log('      "aliasMap":         { "Array": "ArrayCtor" },');
-  logger.log('      "nodeInternalOnly": ["SafeMap", "SafeSet"],');
   logger.log(
     '      "scanDirs":         ["src", "additions/source-patched/lib"]'
   );
   logger.log("    }");
   logger.log("  }");
   logger.log("");
+  logger.log("Only `scanDirs` is required. `aliasMap` and `nodeInternalOnly`");
+  logger.log("default to the fleet-canonical sets and only need entries when");
+  logger.log("your repo extends or overrides them.");
+  logger.log("");
   logger.log("A bare object (no `primordials` section) is also accepted for");
   logger.log("repos that only run this one check.");
 }
 function loadConfig(configPath) {
   if (!(0, import_node_fs.existsSync)(configPath)) {
-    throw new Error(`config file not found: ${configPath}`);
+    throw new import_error.ErrorCtor(`config file not found: ${configPath}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf8"));
+    parsed = (0, import_json.JSONParse)((0, import_node_fs.readFileSync)(configPath, "utf8"));
   } catch (e) {
-    throw new Error(`config file is not valid JSON: ${(0, import_errors.errorMessage)(e)}`);
+    throw new import_error.ErrorCtor(`config file is not valid JSON: ${(0, import_message.errorMessage)(e)}`);
   }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("config root must be an object");
+  if (typeof parsed !== "object" || parsed === null || (0, import_array.ArrayIsArray)(parsed)) {
+    throw new import_error.ErrorCtor("config root must be an object");
   }
   const root = parsed;
   const sectional = root[CONFIG_SECTION];
   const raw = sectional !== void 0 ? sectional : root;
-  if (!Array.isArray(raw.scanDirs)) {
-    throw new Error(
+  if (!(0, import_array.ArrayIsArray)(raw.scanDirs)) {
+    throw new import_error.ErrorCtor(
       `config.scanDirs must be an array of strings (got ${typeof raw.scanDirs})`
     );
   }
   for (const [i, v] of raw.scanDirs.entries()) {
     if (typeof v !== "string") {
-      throw new Error(`config.scanDirs[${i}] must be a string`);
+      throw new import_error.ErrorCtor(`config.scanDirs[${i}] must be a string`);
     }
   }
-  if (raw.aliasMap !== void 0 && (typeof raw.aliasMap !== "object" || raw.aliasMap === null || Array.isArray(raw.aliasMap))) {
-    throw new Error("config.aliasMap must be an object of source\u2192target");
+  if (raw.aliasMap !== void 0 && (typeof raw.aliasMap !== "object" || raw.aliasMap === null || (0, import_array.ArrayIsArray)(raw.aliasMap))) {
+    throw new import_error.ErrorCtor("config.aliasMap must be an object of source\u2192target");
   }
-  if (raw.nodeInternalOnly !== void 0 && !Array.isArray(raw.nodeInternalOnly)) {
-    throw new Error("config.nodeInternalOnly must be an array of strings");
+  if (raw.nodeInternalOnly !== void 0 && !(0, import_array.ArrayIsArray)(raw.nodeInternalOnly)) {
+    throw new import_error.ErrorCtor("config.nodeInternalOnly must be an array of strings");
   }
-  const aliasMap = new Map(
-    Object.entries(raw.aliasMap ?? {})
-  );
-  const nodeInternalOnly = new Set(
-    (raw.nodeInternalOnly ?? []).filter(
+  const aliasMap = new Map([
+    ...(0, import_object.ObjectEntries)(import_primordials_defaults.DEFAULT_ALIAS_MAP),
+    ...(0, import_object.ObjectEntries)(raw.aliasMap ?? {})
+  ]);
+  const nodeInternalOnly = /* @__PURE__ */ new Set([
+    ...import_primordials_defaults.DEFAULT_NODE_INTERNAL_ONLY,
+    ...(raw.nodeInternalOnly ?? []).filter(
       (x) => typeof x === "string"
     )
-  );
+  ]);
   return {
     scanDirs: raw.scanDirs,
     aliasMap,
@@ -206,18 +221,18 @@ async function runCheckPrimordials(argv) {
   try {
     config = loadConfig(import_node_path.default.resolve(resolveConfigPath(args.config)));
   } catch (e) {
-    logger.error(`socket-lib check primordials: ${(0, import_errors.errorMessage)(e)}`);
+    logger.error(`socket-lib check primordials: ${(0, import_message.errorMessage)(e)}`);
     return 1;
   }
   let result;
   try {
     result = (0, import_primordials.checkPrimordials)(config);
   } catch (e) {
-    logger.error(`socket-lib check primordials: ${(0, import_errors.errorMessage)(e)}`);
+    logger.error(`socket-lib check primordials: ${(0, import_message.errorMessage)(e)}`);
     return 1;
   }
   if (args.json) {
-    logger.log(JSON.stringify(serialize(result), null, 2));
+    logger.log((0, import_json.JSONStringify)(serialize(result), null, 2));
   } else {
     renderHuman(result, args);
   }
@@ -225,5 +240,11 @@ async function runCheckPrimordials(argv) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runCheckPrimordials
+  loadConfig,
+  parseArgs,
+  printHelp,
+  renderHuman,
+  resolveConfigPath,
+  runCheckPrimordials,
+  serialize
 });

package/dist/bin/check.d.ts

@@ -1,15 +1,10 @@
 /**
- * @fileoverview `socket-lib check <name>` subcommand group.
- *
- * Routes to per-check handlers by name. Each check resolves its
- * config file and runs its check; the group itself just dispatches
- * and prints help.
- *
- * Available checks:
- *   primordials   Drift between a repo's `primordials` destructures
- *                 and socket-lib's userland mirror.
- *
- * Aliases let callers shorten the common ones:
- *   prim          → primordials
+ * @file `socket-lib check <name>` subcommand group. Routes to per-check
+ *   handlers by name. Each check resolves its config file and runs its check;
+ *   the group itself just dispatches and prints help. Available checks:
+ *   primordials Drift between a repo's `primordials` destructures and
+ *   socket-lib's userland mirror. Aliases let callers shorten the common ones:
+ *   prim → primordials.
  */
+export declare function printHelp(): void;
 export declare function runCheck(args: readonly string[]): Promise<number>;