@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/bin/which.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @file Look up binaries on PATH. Two pairs of public functions: `which` /
+ *   `whichSync` — wrap the upstream `which` package, returning the first
+ *   matching path (or array with `{ all: true }`). Path-like inputs (absolute
+ *   paths, `./relative`, `../relative`) bypass PATH resolution and pass through
+ *   unchanged. Both are tolerant — they return `null` for not-found instead of
+ *   throwing. `whichReal` / `whichRealSync` — same but resolve the result
+ *   through `resolveRealBinSync` so the caller gets the underlying script path
+ *   (e.g., `npm-cli.js`) rather than the wrapper. Default `nothrow: true` so a
+ *   missing binary returns `undefined` instead of bubbling a `which` package
+ *   error. Caching matches `_internal.binPathCache` and `binPathAllCache`. Both
+ *   caches validate hits with `existsSync` so a tool reinstall mid-session
+ *   doesn't return a stale path.
+ */
+import type { WhichOptions } from './types';
+/**
+ * Find an executable in the system PATH asynchronously.
+ *
+ * This function resolves binary names to their full paths by searching the
+ * system PATH. It should only be used for binary names (not paths). If the
+ * input is already a path (absolute or relative), it will be returned as-is
+ * without PATH resolution.
+ *
+ * Binary name vs. path detection:
+ *
+ * - Binary names: 'npm', 'git', 'node' - will be resolved via PATH
+ * - Absolute paths: '/usr/bin/node', 'C:\Program Files\nodejs\node.exe' -
+ *   returned as-is
+ * - Relative paths: './node', '../bin/npm' - returned as-is
+ *
+ * @example
+ *   ;```typescript
+ *   // Resolve binary names
+ *   await which('node') // '/usr/local/bin/node'
+ *   await which('npm') // '/usr/local/bin/npm'
+ *   await which('nonexistent') // null
+ *
+ *   // Paths are returned as-is
+ *   await which('/usr/bin/node') // '/usr/bin/node'
+ *   await which('./local-script') // './local-script'
+ *   ```
+ *
+ * @param {string} binName - The binary name to resolve (e.g., 'npm', 'git')
+ * @param {WhichOptions | undefined} options - Options for resolution.
+ *
+ * @returns {Promise<string | string[] | null>} Promise resolving to the full
+ *   path, the original path, or null if not found.
+ */
+export declare function which(binName: string, options?: WhichOptions): Promise<string | string[] | null>;
+/**
+ * Find a binary in the system PATH and resolve to the real underlying script
+ * asynchronously. Resolves wrapper scripts (.cmd, .ps1, shell scripts) to the
+ * actual .js files they execute.
+ *
+ * @example
+ *   ;```typescript
+ *   const npmPath = await whichReal('npm')
+ *   // e.g. '/usr/local/lib/node_modules/npm/bin/npm-cli.js'
+ *   ```
+ *
+ * @throws {Error} If the binary is not found and nothrow is false.
+ */
+export declare function whichReal(binName: string, options?: WhichOptions): Promise<string | string[] | undefined>;
+/**
+ * Find a binary in the system PATH and resolve to the real underlying script
+ * synchronously. Resolves wrapper scripts (.cmd, .ps1, shell scripts) to the
+ * actual .js files they execute.
+ *
+ * @example
+ *   ;```typescript
+ *   const npmPath = whichRealSync('npm')
+ *   // e.g. '/usr/local/lib/node_modules/npm/bin/npm-cli.js'
+ *   ```
+ *
+ * @throws {Error} If the binary is not found and nothrow is false.
+ */
+export declare function whichRealSync(binName: string, options?: WhichOptions): string | string[] | undefined;
+/**
+ * Find an executable in the system PATH synchronously.
+ *
+ * This function resolves binary names to their full paths by searching the
+ * system PATH. It should only be used for binary names (not paths). If the
+ * input is already a path (absolute or relative), it will be returned as-is
+ * without PATH resolution.
+ *
+ * Binary name vs. path detection:
+ *
+ * - Binary names: 'npm', 'git', 'node' - will be resolved via PATH
+ * - Absolute paths: '/usr/bin/node', 'C:\Program Files\nodejs\node.exe' -
+ *   returned as-is
+ * - Relative paths: './node', '../bin/npm' - returned as-is
+ *
+ * @example
+ *   ;```typescript
+ *   // Resolve binary names
+ *   whichSync('node') // '/usr/local/bin/node'
+ *   whichSync('npm') // '/usr/local/bin/npm'
+ *   whichSync('nonexistent') // null
+ *
+ *   // Paths are returned as-is
+ *   whichSync('/usr/bin/node') // '/usr/bin/node'
+ *   whichSync('./local-script') // './local-script'
+ *   ```
+ *
+ * @param {string} binName - The binary name to resolve (e.g., 'npm', 'git')
+ * @param {WhichOptions | undefined} options - Options for resolution.
+ *
+ * @returns {string | string[] | null} The full path to the binary, the original
+ *   path if input is a path, or null if not found.
+ */
+export declare function whichSync(binName: string, options?: WhichOptions): string | string[] | null;

package/dist/bin/which.js

@@ -0,0 +1,155 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var which_exports = {};
+__export(which_exports, {
+  which: () => which,
+  whichReal: () => whichReal,
+  whichRealSync: () => whichRealSync,
+  whichSync: () => whichSync
+});
+module.exports = __toCommonJS(which_exports);
+var import_which = __toESM(require("../external/which"));
+var import_normalize = require("../paths/normalize");
+var import_array = require("../primordials/array");
+var import_internal = require("./_internal");
+var import_resolve = require("./resolve");
+async function which(binName, options) {
+  if ((0, import_normalize.isPath)(binName)) {
+    return binName;
+  }
+  try {
+    const result = await (0, import_which.default)(
+      binName,
+      options
+    );
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function whichReal(binName, options) {
+  const fs = (0, import_internal.getFs)();
+  const opts = { __proto__: null, nothrow: true, ...options };
+  if (opts.all) {
+    const cachedAll = import_internal.binPathAllCache.get(binName);
+    if (cachedAll && cachedAll.length > 0) {
+      if (fs.existsSync(cachedAll[0])) {
+        return cachedAll;
+      }
+      import_internal.binPathAllCache.delete(binName);
+    }
+  } else {
+    const cached = import_internal.binPathCache.get(binName);
+    if (cached) {
+      if (fs.existsSync(cached)) {
+        return cached;
+      }
+      import_internal.binPathCache.delete(binName);
+    }
+  }
+  const result = await (0, import_which.default)(
+    binName,
+    opts
+  );
+  if (opts?.all) {
+    const paths = (0, import_array.ArrayIsArray)(result) ? result : typeof result === "string" ? [result] : void 0;
+    if (paths?.length) {
+      const resolved2 = (0, import_array.ArrayPrototypeMap)(paths, (p) => (0, import_resolve.resolveRealBinSync)(p));
+      import_internal.binPathAllCache.set(binName, resolved2);
+      return resolved2;
+    }
+    return paths;
+  }
+  if (!result) {
+    return void 0;
+  }
+  const resolved = (0, import_resolve.resolveRealBinSync)(result);
+  import_internal.binPathCache.set(binName, resolved);
+  return resolved;
+}
+function whichRealSync(binName, options) {
+  const fs = (0, import_internal.getFs)();
+  const opts = { __proto__: null, nothrow: true, ...options };
+  if (opts.all) {
+    const cachedAll = import_internal.binPathAllCache.get(binName);
+    if (cachedAll && cachedAll.length > 0) {
+      if (fs.existsSync(cachedAll[0])) {
+        return cachedAll;
+      }
+      import_internal.binPathAllCache.delete(binName);
+    }
+  } else {
+    const cached = import_internal.binPathCache.get(binName);
+    if (cached) {
+      if (fs.existsSync(cached)) {
+        return cached;
+      }
+      import_internal.binPathCache.delete(binName);
+    }
+  }
+  const result = whichSync(binName, opts);
+  if (opts.all) {
+    const paths = (0, import_array.ArrayIsArray)(result) ? result : typeof result === "string" ? [result] : void 0;
+    if (paths?.length) {
+      const resolved2 = (0, import_array.ArrayPrototypeMap)(paths, (p) => (0, import_resolve.resolveRealBinSync)(p));
+      import_internal.binPathAllCache.set(binName, resolved2);
+      return resolved2;
+    }
+    return paths;
+  }
+  if (!result) {
+    return void 0;
+  }
+  const resolved = (0, import_resolve.resolveRealBinSync)(result);
+  import_internal.binPathCache.set(binName, resolved);
+  return resolved;
+}
+function whichSync(binName, options) {
+  if ((0, import_normalize.isPath)(binName)) {
+    return binName;
+  }
+  try {
+    const result = import_which.default.sync(
+      binName,
+      options
+    );
+    return result;
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  which,
+  whichReal,
+  whichRealSync,
+  whichSync
+});

package/dist/cacache/_internal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Accessor for the vendored `cacache` module. Centralised so other
+ *   `cacache/*` leaves stay decoupled from the import path — if the vendoring
+ *   moves, only this leaf updates.
+ */
+/**
+ * Get the cacache module for cache operations.
+ *
+ * @example
+ *   ;```typescript
+ *   const cacache = getCacache()
+ *   const entries = await cacache.ls(cacheDir)
+ *   ```
+ */
+export declare function getCacache(): import("../external/cacache").CacacheInstance;

package/dist/cacache/_internal.js

@@ -0,0 +1,43 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  getCacache: () => getCacache
+});
+module.exports = __toCommonJS(internal_exports);
+var import_cacache = __toESM(require("../external/cacache"));
+function getCacache() {
+  return import_cacache.default;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCacache
+});

package/dist/cacache/clear.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Bulk-clear entries from the Socket shared cacache — `clear()` plus its
+ *   wildcard helper `createPatternMatcher`. The helper is exported because
+ *   callers occasionally compose their own filtering pipelines.
+ */
+import type { RemoveOptions } from './types';
+/**
+ * Clear entries from the Socket shared cache.
+ *
+ * Supports wildcard patterns (*) in prefix for flexible matching. For simple
+ * prefixes without wildcards, uses efficient streaming. For wildcard patterns,
+ * iterates and matches each entry.
+ *
+ * @example
+ *   // Clear all entries
+ *   await clear()
+ *
+ * @example
+ *   // Clear entries with simple prefix
+ *   const removed = await clear({ prefix: 'socket-sdk:scans' })
+ *   console.log(`Removed ${removed} scan cache entries`)
+ *
+ * @example
+ *   // Clear entries with wildcard pattern
+ *   await clear({ prefix: 'socket-sdk:scans:abc*' })
+ *   await clear({ prefix: 'socket-sdk:npm/lodash/*' })
+ *
+ * @param options - Optional configuration for selective clearing.
+ * @param options.prefix - Prefix or pattern to match (supports * wildcards)
+ *
+ * @returns Number of entries removed (only when prefix is specified)
+ */
+export declare function clear(options?: RemoveOptions | undefined): Promise<number | undefined>;
+/**
+ * Build a key→boolean matcher for `pattern`. For non-wildcard patterns this
+ * returns a prefix-startsWith predicate (no regex allocation); for wildcard
+ * patterns it compiles the regex _once_ and closes over it so the caller can
+ * apply the same matcher across N keys in O(1)-per-key.
+ *
+ * Anchors both ends — `foo*bar` matches exactly `foo<anything>bar`, not
+ * `foo<anything>bar<more>`.
+ */
+export declare function createPatternMatcher(pattern: string): (key: string) => boolean;

package/dist/cacache/clear.js

@@ -0,0 +1,77 @@
+"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 clear_exports = {};
+__export(clear_exports, {
+  clear: () => clear,
+  createPatternMatcher: () => createPatternMatcher
+});
+module.exports = __toCommonJS(clear_exports);
+var import_socket = require("../paths/socket");
+var import_regexp = require("../primordials/regexp");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+async function clear(options) {
+  const opts = { __proto__: null, ...options };
+  const cacache = (0, import_internal.getCacache)();
+  const cacheDir = (0, import_socket.getSocketCacacheDir)();
+  if (!opts.prefix) {
+    try {
+      await cacache.rm.all(cacheDir);
+      return;
+    } catch (e) {
+      if (e?.code !== "ENOTEMPTY") {
+        throw e;
+      }
+      return;
+    }
+  }
+  let removed = 0;
+  const matches = createPatternMatcher(opts.prefix);
+  const stream = cacache.ls.stream(cacheDir);
+  for await (const entry of stream) {
+    if (matches(entry.key)) {
+      try {
+        await cacache.rm.entry(cacheDir, entry.key);
+        removed++;
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+function createPatternMatcher(pattern) {
+  if (!pattern.includes("*")) {
+    return (key) => (0, import_string.StringPrototypeStartsWith)(key, pattern);
+  }
+  const escaped = (0, import_string.StringPrototypeReplaceAll)(
+    pattern,
+    /[.+?^${}()|[\]\\]/g,
+    "\\$&"
+  );
+  const regexPattern = (0, import_string.StringPrototypeReplaceAll)(escaped, "*", ".*");
+  const regex = new import_regexp.RegExpCtor(`^${regexPattern}$`);
+  return (key) => (0, import_regexp.RegExpPrototypeTest)(regex, key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clear,
+  createPatternMatcher
+});

package/dist/cacache/read.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Cache read entrypoints — `get` (throws on miss) and `safeGet` (returns
+ *   `undefined` on miss). Both reject keys containing wildcards; bulk reads go
+ *   through `clear` / `ls` patterns.
+ */
+import type { CacheEntry, GetOptions } from './types';
+/**
+ * Get data from the Socket shared cache by key.
+ *
+ * @example
+ *   ;```typescript
+ *   const entry = await get('socket-sdk:scans:abc123')
+ *   console.log(entry.data.toString('utf8'))
+ *   ```
+ *
+ * @throws {Error} When cache entry is not found.
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function get(key: string, options?: GetOptions | undefined): Promise<CacheEntry>;
+/**
+ * Get data from the Socket shared cache by key without throwing.
+ *
+ * @example
+ *   ;```typescript
+ *   const entry = await safeGet('socket-sdk:scans:abc123')
+ *   if (entry) {
+ *     console.log(entry.data.toString('utf8'))
+ *   }
+ *   ```
+ */
+export declare function safeGet(key: string, options?: GetOptions | undefined): Promise<CacheEntry | undefined>;

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>;