@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/checks/primordials.d.ts

@@ -1,62 +1,53 @@
 /**
- * @fileoverview Primordials drift check — generic core.
- *
- * Each fleet repo that destructures from Node's internal `primordials`
- * global needs to keep its usage shape-aligned with socket-lib's
- * userland mirror (`@socketsecurity/lib/primordials`). This module is
- * the parser + diff engine; per-repo policy (which dirs to scan,
- * naming aliases, allowlist) lives in a config the caller supplies.
- *
- * Used by the `socket-lib check primordials` CLI subcommand. Kept
- * importable as a library so repos with bespoke needs can compose it
- * directly without going through the CLI.
- *
- * The flow:
+ * @file Primordials drift check — generic core. Each fleet repo that
+ *   destructures from Node's internal `primordials` global needs to keep its
+ *   usage shape-aligned with socket-lib's userland mirror
+ *   (`@socketsecurity/lib/primordials`). This module is the parser + diff
+ *   engine; per-repo policy (which dirs to scan, naming aliases, allowlist)
+ *   lives in a config the caller supplies. Used by the `socket-lib check
+ *   primordials` CLI subcommand. Kept importable as a library so repos with
+ *   bespoke needs can compose it directly without going through the CLI. The
+ *   flow:
  *
  *   1. Walk the configured `scanDirs` for `*.js` files.
- *   2. From each file, extract names from every
- *      `const { Foo, Bar } = primordials` destructure.
- *   3. Read socket-lib's `primordials.ts` (sibling clone) or
- *      `primordials.d.ts` (installed `node_modules`) and pull every
- *      exported name.
- *   4. Diff: every destructured name must be either (a) in socket-lib
- *      verbatim, (b) in socket-lib via the configured alias map, or
- *      (c) in the configured node-internal-only allowlist.
- *
- * Findings come back classified so callers can render or fail-CI on
- * specific kinds.
+ *   2. From each file, extract names from every `const { Foo, Bar } = primordials`
+ *      destructure.
+ *   3. Read socket-lib's `primordials/` directory (sibling clone) or
+ *      `primordials/*.d.ts` (installed `node_modules`) and pull every exported
+ *      name across all leaves.
+ *   4. Diff: every destructured name must be either (a) in socket-lib verbatim,
+ *      (b) in socket-lib via the configured alias map, or (c) in the configured
+ *      node-internal-only allowlist. Findings come back classified so callers
+ *      can render or fail-CI on specific kinds.
  */
 export interface PrimordialsCheckConfig {
     /**
-     * Repo-relative directories to scan recursively for `*.js` files
-     * containing `primordials` destructures. Each entry is resolved
-     * against `repoRoot`.
+     * Repo-relative directories to scan recursively for `*.js` files containing
+     * `primordials` destructures. Each entry is resolved against `repoRoot`.
      */
     readonly scanDirs: readonly string[];
     /**
-     * Map from the source name a repo destructures (e.g. `Array`) to
-     * the socket-lib export name it should resolve to (e.g.
-     * `ArrayCtor`). socket-lib uses the `Ctor` suffix to avoid
-     * shadowing globals; repos that need the original name go through
-     * the alias.
+     * Map from the source name a repo destructures (e.g. `Array`) to the
+     * socket-lib export name it should resolve to (e.g. `ArrayCtor`). socket-lib
+     * uses the `Ctor` suffix to avoid shadowing globals; repos that need the
+     * original name go through the alias.
      */
     readonly aliasMap: ReadonlyMap<string, string>;
     /**
      * Names that exist only in Node's internal `primordials` and are
-     * intentionally NOT mirrored to socket-lib. Adding to this set is
-     * a deliberate decision per name.
+     * intentionally NOT mirrored to socket-lib. Adding to this set is a
+     * deliberate decision per name.
      */
     readonly nodeInternalOnly: ReadonlySet<string>;
     /**
-     * Override the auto-resolution of socket-lib's primordials source.
-     * Useful for tests; production callers should leave this undefined
-     * so the resolver picks sibling clone → installed `node_modules`.
+     * Override the auto-resolution of socket-lib's primordials source. Useful for
+     * tests; production callers should leave this undefined so the resolver picks
+     * sibling clone → installed `node_modules`.
      */
     readonly socketLibPrimordialsPath?: string | undefined;
     /**
-     * Repo root used to resolve `scanDirs` and to anchor the
-     * sibling-clone fallback (`<repoRoot>/../socket-lib/...`). Defaults
-     * to `process.cwd()`.
+     * Repo root used to resolve `scanDirs` and to anchor the sibling-clone
+     * fallback (`<repoRoot>/../socket-lib/...`). Defaults to `process.cwd()`.
      */
     readonly repoRoot?: string | undefined;
 }
@@ -73,38 +64,55 @@ export interface PrimordialsCheckResult {
     readonly findings: readonly PrimordialsFinding[];
 }
 /**
- * Pull every `const { … } = primordials` destructure body out of
- * `src`. Comments are stripped first so commentary inside a
- * destructure doesn't leak into captured names. The body regex
- * disallows nested `}`, which is safe after the comment-strip pass —
- * destructures themselves don't contain `}`.
+ * Run the primordials drift check against the configured repo. Returns the full
+ * result including raw inputs (used names, lib exports) so renderers can show
+ * context, plus a sorted list of findings classified by kind.
+ */
+export declare function checkPrimordials(config: PrimordialsCheckConfig): PrimordialsCheckResult;
+/**
+ * Recursively collect every `*.js` file under `dir`.
+ */
+export declare function collectJsFiles(dir: string): string[];
+/**
+ * Pull every `const { … } = primordials` destructure body out of `src`.
+ * Comments are stripped first so commentary inside a destructure doesn't leak
+ * into captured names. The body regex disallows nested `}`, which is safe after
+ * the comment-strip pass — destructures themselves don't contain `}`.
  */
 export declare function extractPrimordialsNames(src: string): string[];
 /**
- * Pull every `export const Foo` / `export function Foo` /
- * `export { Foo }` from a TS file. Also matches `.d.ts` declaration
- * forms (`export declare const Foo`, `export declare function Foo`)
- * since the fallback path reads `primordials.d.ts` from
- * `node_modules` when no sibling clone is present.
+ * Pull every `export const Foo` / `export function Foo` / `export { Foo }` from
+ * a TS file. Also matches `.d.ts` declaration forms (`export declare const
+ * Foo`, `export declare function Foo`) since the fallback path reads
+ * `primordials.d.ts` from `node_modules` when no sibling clone is present.
  */
 export declare function extractTsExports(src: string): string[];
+/**
+ * Read TS exports from a resolved primordials path. Handles both the legacy
+ * single-file layout (returns one file's exports) and the post-split directory
+ * layout (concatenates exports across every `*.ts` / `*.d.ts` leaf).
+ */
+export declare function readSocketLibPrimordialNames(resolved: string): Set<string>;
 /**
  * Locate socket-lib's primordials source. Search order:
  *
- *   1. `config.socketLibPrimordialsPath` if explicitly set.
- *   2. Sibling clone — `<repoRoot>/../socket-lib/src/primordials.ts`.
- *      Preferred for the dev-loop case where a developer is editing
- *      socket-lib and a consumer in parallel.
- *   3. Installed copy — `<repoRoot>/node_modules/@socketsecurity/lib/
- *      dist/primordials.d.ts`. The CI fallback.
+ * 1. `config.socketLibPrimordialsPath` if explicitly set. Accepts either a single
+ *    file (legacy `primordials.ts` / `.d.ts`) or a directory of leaves
+ *    (`primordials/`).
+ * 2. Sibling clone — `<repoRoot>/../socket-lib/src/primordials/` (post-split
+ *    layout) or `<repoRoot>/../socket-lib/src/primordials.ts` (legacy
+ *    single-file layout). Preferred for the dev-loop case where a developer is
+ *    editing socket-lib and a consumer in parallel.
+ * 3. Installed copy — `<repoRoot>/node_modules/@socketsecurity/lib/
+ *    dist/primordials/` (post-split) or `<repoRoot>/node_modules/
+ *    @socketsecurity/lib/dist/primordials.d.ts` (legacy). The CI fallback.
  *
  * Throws when none of the candidates exist.
  */
 export declare function resolveSocketLibPrimordials(config: PrimordialsCheckConfig): string;
 /**
- * Run the primordials drift check against the configured repo.
- * Returns the full result including raw inputs (used names, lib
- * exports) so renderers can show context, plus a sorted list of
- * findings classified by kind.
+ * Strip `/* … *‍/` block comments and `//` line comments. Comments inside
+ * primordials destructures would otherwise leak captured names; stripping first
+ * keeps the regex simple.
  */
-export declare function checkPrimordials(config: PrimordialsCheckConfig): PrimordialsCheckResult;
+export declare function stripComments(src: string): string;

package/dist/checks/primordials.js

@@ -31,20 +31,91 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var primordials_exports = {};
 __export(primordials_exports, {
   checkPrimordials: () => checkPrimordials,
+  collectJsFiles: () => collectJsFiles,
   extractPrimordialsNames: () => extractPrimordialsNames,
   extractTsExports: () => extractTsExports,
-  resolveSocketLibPrimordials: () => resolveSocketLibPrimordials
+  readSocketLibPrimordialNames: () => readSocketLibPrimordialNames,
+  resolveSocketLibPrimordials: () => resolveSocketLibPrimordials,
+  stripComments: () => stripComments
 });
 module.exports = __toCommonJS(primordials_exports);
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"));
-var import_arrays = require("../arrays");
+var import_join = require("../arrays/join");
+var import_error = require("../primordials/error");
 const NAME_HEAD_RE = /^([A-Za-z_$][A-Za-z0-9_$]*)/;
-function stripComments(src) {
-  let out = src.replace(/\/\*[\s\S]*?\*\//g, "");
-  out = out.replace(/^[\t ]*\/\/.*$/gm, "");
-  out = out.replace(/[\t ]+\/\/.*$/gm, "");
-  return out;
+function checkPrimordials(config) {
+  const repoRoot = config.repoRoot ?? process.cwd();
+  const used = /* @__PURE__ */ new Set();
+  const usedToFiles = /* @__PURE__ */ new Map();
+  for (const dir of config.scanDirs) {
+    const fullDir = import_node_path.default.resolve(repoRoot, dir);
+    const jsFiles = collectJsFiles(fullDir);
+    for (const file of jsFiles) {
+      let src;
+      try {
+        src = (0, import_node_fs.readFileSync)(file, "utf8");
+      } catch {
+        continue;
+      }
+      if (!src.includes("primordials")) {
+        continue;
+      }
+      const names = extractPrimordialsNames(src);
+      if (names.length === 0) {
+        continue;
+      }
+      const rel = import_node_path.default.relative(repoRoot, file);
+      for (const name of names) {
+        used.add(name);
+        const arr = usedToFiles.get(name) ?? [];
+        if (!arr.includes(rel)) {
+          arr.push(rel);
+        }
+        usedToFiles.set(name, arr);
+      }
+    }
+  }
+  const socketLibPath = resolveSocketLibPrimordials(config);
+  const socketLibNames = readSocketLibPrimordialNames(socketLibPath);
+  const findings = [];
+  for (const name of [...used].sort()) {
+    if (config.nodeInternalOnly.has(name)) {
+      continue;
+    }
+    if (socketLibNames.has(name)) {
+      continue;
+    }
+    const aliased = config.aliasMap.get(name);
+    if (aliased) {
+      if (socketLibNames.has(aliased)) {
+        continue;
+      }
+      findings.push({
+        kind: "missing-from-socket-lib",
+        name,
+        files: usedToFiles.get(name) ?? [],
+        hint: `\`${name}\` is mapped to socket-lib's \`${aliased}\`, but \`${aliased}\` is not exported. Add \`export const ${aliased} = ${name}\` to the appropriate leaf under socket-lib/src/primordials/.`
+      });
+      continue;
+    }
+    findings.push({
+      kind: "unmapped",
+      name,
+      files: usedToFiles.get(name) ?? [],
+      hint: `\`${name}\` is destructured from \`primordials\` but no socket-lib mapping exists. Pick one: ` + (0, import_join.joinOr)([
+        `add \`${name}\` to the appropriate leaf under socket-lib/src/primordials/`,
+        `add a \`${name}\` \u2192 \`<libName>\` entry to the alias map`,
+        `add \`${name}\` to nodeInternalOnly (if Node-internal only)`
+      ]) + "."
+    });
+  }
+  return {
+    used,
+    usedToFiles,
+    socketLibNames,
+    findings
+  };
 }
 function collectJsFiles(dir) {
   const out = [];
@@ -122,27 +193,69 @@ function extractTsExports(src) {
   }
   return [...out];
 }
+function readSocketLibPrimordialNames(resolved) {
+  const stat = (0, import_node_fs.statSync)(resolved);
+  if (stat.isFile()) {
+    return new Set(extractTsExports((0, import_node_fs.readFileSync)(resolved, "utf8")));
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const name of (0, import_node_fs.readdirSync)(resolved)) {
+    if (!name.endsWith(".ts") && !name.endsWith(".d.ts")) {
+      continue;
+    }
+    const full = import_node_path.default.join(resolved, name);
+    const fileStat = (0, import_node_fs.statSync)(full);
+    if (!fileStat.isFile()) {
+      continue;
+    }
+    for (const exp of extractTsExports((0, import_node_fs.readFileSync)(full, "utf8"))) {
+      out.add(exp);
+    }
+  }
+  return out;
+}
 function resolveSocketLibPrimordials(config) {
   if (config.socketLibPrimordialsPath) {
     if (!(0, import_node_fs.existsSync)(config.socketLibPrimordialsPath)) {
-      throw new Error(
+      throw new import_error.ErrorCtor(
         `socketLibPrimordialsPath does not exist: ${config.socketLibPrimordialsPath}`
       );
     }
     return config.socketLibPrimordialsPath;
   }
   const repoRoot = config.repoRoot ?? process.cwd();
-  const sibling = import_node_path.default.resolve(
+  const siblingDir = import_node_path.default.resolve(
+    repoRoot,
+    "..",
+    "socket-lib",
+    "src",
+    "primordials"
+  );
+  if ((0, import_node_fs.existsSync)(siblingDir)) {
+    return siblingDir;
+  }
+  const siblingLegacy = import_node_path.default.resolve(
     repoRoot,
     "..",
     "socket-lib",
     "src",
     "primordials.ts"
   );
-  if ((0, import_node_fs.existsSync)(sibling)) {
-    return sibling;
+  if ((0, import_node_fs.existsSync)(siblingLegacy)) {
+    return siblingLegacy;
+  }
+  const installedDir = import_node_path.default.resolve(
+    repoRoot,
+    "node_modules",
+    "@socketsecurity",
+    "lib",
+    "dist",
+    "primordials"
+  );
+  if ((0, import_node_fs.existsSync)(installedDir)) {
+    return installedDir;
   }
-  const installed = import_node_path.default.resolve(
+  const installedLegacy = import_node_path.default.resolve(
     repoRoot,
     "node_modules",
     "@socketsecurity",
@@ -150,95 +263,31 @@ function resolveSocketLibPrimordials(config) {
     "dist",
     "primordials.d.ts"
   );
-  if ((0, import_node_fs.existsSync)(installed)) {
-    return installed;
+  if ((0, import_node_fs.existsSync)(installedLegacy)) {
+    return installedLegacy;
   }
-  throw new Error(
+  throw new import_error.ErrorCtor(
     `Cannot locate socket-lib primordials source. Looked at:
-  ${sibling}
-  ${installed}
+  ${siblingDir}
+  ${siblingLegacy}
+  ${installedDir}
+  ${installedLegacy}
 Either clone socket-lib at ../socket-lib or run \`pnpm install\`.`
   );
 }
-function checkPrimordials(config) {
-  const repoRoot = config.repoRoot ?? process.cwd();
-  const used = /* @__PURE__ */ new Set();
-  const usedToFiles = /* @__PURE__ */ new Map();
-  for (const dir of config.scanDirs) {
-    const fullDir = import_node_path.default.resolve(repoRoot, dir);
-    const jsFiles = collectJsFiles(fullDir);
-    for (const file of jsFiles) {
-      let src;
-      try {
-        src = (0, import_node_fs.readFileSync)(file, "utf8");
-      } catch {
-        continue;
-      }
-      if (!src.includes("primordials")) {
-        continue;
-      }
-      const names = extractPrimordialsNames(src);
-      if (names.length === 0) {
-        continue;
-      }
-      const rel = import_node_path.default.relative(repoRoot, file);
-      for (const name of names) {
-        used.add(name);
-        const arr = usedToFiles.get(name) ?? [];
-        if (!arr.includes(rel)) {
-          arr.push(rel);
-        }
-        usedToFiles.set(name, arr);
-      }
-    }
-  }
-  const socketLibPath = resolveSocketLibPrimordials(config);
-  const socketLibNames = new Set(
-    extractTsExports((0, import_node_fs.readFileSync)(socketLibPath, "utf8"))
-  );
-  const findings = [];
-  for (const name of [...used].sort()) {
-    if (config.nodeInternalOnly.has(name)) {
-      continue;
-    }
-    if (socketLibNames.has(name)) {
-      continue;
-    }
-    const aliased = config.aliasMap.get(name);
-    if (aliased) {
-      if (socketLibNames.has(aliased)) {
-        continue;
-      }
-      findings.push({
-        kind: "missing-from-socket-lib",
-        name,
-        files: usedToFiles.get(name) ?? [],
-        hint: `\`${name}\` is mapped to socket-lib's \`${aliased}\`, but \`${aliased}\` is not exported. Add \`export const ${aliased} = ${name}\` to socket-lib/src/primordials.ts.`
-      });
-      continue;
-    }
-    findings.push({
-      kind: "unmapped",
-      name,
-      files: usedToFiles.get(name) ?? [],
-      hint: `\`${name}\` is destructured from \`primordials\` but no socket-lib mapping exists. Pick one: ` + (0, import_arrays.joinOr)([
-        `add \`${name}\` to socket-lib/src/primordials.ts`,
-        `add a \`${name}\` \u2192 \`<libName>\` entry to the alias map`,
-        `add \`${name}\` to nodeInternalOnly (if Node-internal only)`
-      ]) + "."
-    });
-  }
-  return {
-    used,
-    usedToFiles,
-    socketLibNames,
-    findings
-  };
+function stripComments(src) {
+  let out = src.replace(/\/\*[\s\S]*?\*\//g, "");
+  out = out.replace(/^[\t ]*\/\/.*$/gm, "");
+  out = out.replace(/[\t ]+\/\/.*$/gm, "");
+  return out;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkPrimordials,
+  collectJsFiles,
   extractPrimordialsNames,
   extractTsExports,
-  resolveSocketLibPrimordials
+  readSocketLibPrimordialNames,
+  resolveSocketLibPrimordials,
+  stripComments
 });

package/dist/colors/convert.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Color conversion helpers — `isRgbTuple()` narrows a `ColorValue` to the
+ *   RGB-tuple branch, and `toRgb()` resolves a named color or passes through an
+ *   existing tuple.
+ */
+import type { ColorRgb, ColorValue } from './types';
+/**
+ * Type guard to check if a color value is an RGB tuple.
+ *
+ * @example
+ *   ;```typescript
+ *   isRgbTuple([255, 0, 0]) // true
+ *   isRgbTuple('red') // false
+ *   ```
+ *
+ * @param value - Color value to check.
+ *
+ * @returns `true` if value is an RGB tuple, `false` if it's a color name
+ */
+export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
+/**
+ * Convert a color value to RGB tuple format. Named colors are looked up in the
+ * `colorToRgb` map, RGB tuples are returned as-is.
+ *
+ * @example
+ *   ;```typescript
+ *   toRgb('red') // [255, 0, 0]
+ *   toRgb([0, 128, 0]) // [0, 128, 0]
+ *   ```
+ *
+ * @param color - Color name or RGB tuple.
+ *
+ * @returns RGB tuple with values 0-255
+ */
+export declare function toRgb(color: ColorValue): ColorRgb;

package/dist/colors/convert.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 convert_exports = {};
+__export(convert_exports, {
+  isRgbTuple: () => isRgbTuple,
+  toRgb: () => toRgb
+});
+module.exports = __toCommonJS(convert_exports);
+var import_array = require("../primordials/array");
+var import_palette = require("./palette");
+function isRgbTuple(value) {
+  return (0, import_array.ArrayIsArray)(value);
+}
+function toRgb(color) {
+  if (isRgbTuple(color)) {
+    return color;
+  }
+  return import_palette.colorToRgb[color];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRgbTuple,
+  toRgb
+});

package/dist/colors/palette.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Named-color palette — maps each `ColorName` to its canonical RGB tuple.
+ *   Consumed by `colors/convert` and surfaced to downstream renderers (shimmer,
+ *   gradient, pulse) that need numeric channel values for color blending.
+ */
+import type { ColorName, ColorRgb } from './types';
+export declare const colorToRgb: Record<ColorName, ColorRgb>;

package/dist/{colors.js → colors/palette.js}

@@ -18,13 +18,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var colors_exports = {};
-__export(colors_exports, {
-  isRgbTuple: () => isRgbTuple,
-  toRgb: () => toRgb
+var palette_exports = {};
+__export(palette_exports, {
+  colorToRgb: () => colorToRgb
 });
-module.exports = __toCommonJS(colors_exports);
-var import_primordials = require("./primordials");
+module.exports = __toCommonJS(palette_exports);
 const colorToRgb = {
   __proto__: null,
   black: [0, 0, 0],
@@ -44,17 +42,7 @@ const colorToRgb = {
   yellow: [255, 255, 0],
   yellowBright: [255, 255, 153]
 };
-function isRgbTuple(value) {
-  return (0, import_primordials.ArrayIsArray)(value);
-}
-function toRgb(color) {
-  if (isRgbTuple(color)) {
-    return color;
-  }
-  return colorToRgb[color];
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isRgbTuple,
-  toRgb
+  colorToRgb
 });

package/dist/colors/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Public type surface for `colors/*` modules — the `ColorInherit`
+ *   literal, the `ColorName` named-color union, the `ColorRgb` tuple, and the
+ *   `ColorValue` super-union. Pure types, no runtime side effects.
+ */
+/**
+ * Special 'inherit' color value that uses the current color context. Used with
+ * effects like shimmer to dynamically inherit color.
+ */
+export type ColorInherit = 'inherit';
+/**
+ * Named color values supported by the library. Maps to standard terminal colors
+ * with bright variants.
+ */
+export type ColorName = 'black' | 'blue' | 'blueBright' | 'cyan' | 'cyanBright' | 'gray' | 'green' | 'greenBright' | 'magenta' | 'magentaBright' | 'red' | 'redBright' | 'white' | 'whiteBright' | 'yellow' | 'yellowBright';
+/**
+ * RGB color tuple with values 0-255 for red, green, and blue channels.
+ *
+ * @example
+ *   ;[140, 82, 255] // Socket purple
+ *
+ * @example
+ *   ;[255, 0, 0] // Red
+ */
+export type ColorRgb = readonly [number, number, number];
+/**
+ * Union of all supported color types: named colors or RGB tuples.
+ */
+export type ColorValue = ColorName | ColorRgb;

package/dist/colors/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/compression/_internal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Private internals for `compression/*` modules — `resolveFileArgs`
+ *   disambiguates the `(src, dest, options?)` vs `(src, options)` calling
+ *   shape, and `stripExt` removes a trailing extension when it matches one of a
+ *   caller-supplied set. Both are shared by the brotli and gzip leaves and have
+ *   no callers outside this directory.
+ */
+import type { CompressFileOptions, CompressOptions } from './types';
+/**
+ * Strip the trailing extension from a filename when it matches one of `exts`.
+ * Returns the input unchanged when the trailing extname isn't in the set.
+ * Case-insensitive on the extension — preserves the rest of the path's casing.
+ *
+ * The `exts` set decides what counts. Pass `BROTLI_EXTS` / `GZIP_EXTS` for the
+ * canonical compression sets, or your own set for custom classifiers.
+ *
+ * Generic — it does NOT know that `.tgz` is short for `.tar.gz`. Callers that
+ * need that convention compose this with their own follow-up (see
+ * `decompressGzipFile` for the canonical example).
+ */
+export declare function stripExt(filePath: string, exts: ReadonlySet<string>): string;
+export interface ResolvedFileArgs {
+    destPath: string;
+    options: CompressOptions | undefined;
+    inPlace: boolean;
+}
+/**
+ * Disambiguate the `(src, dest, options?)` and `(src, options)` call shapes.
+ * Returns the resolved destPath, options, and inPlace flag. Validates that the
+ * explicit destPath is not the same as srcPath, since same-path streams would
+ * deadlock on read.
+ */
+export declare function resolveFileArgs(fnName: string, srcPath: string, destOrOptions: string | CompressFileOptions | undefined, maybeOptions: CompressOptions | undefined, computeInPlaceDest: (src: string) => string): ResolvedFileArgs;