@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/promises.js

@@ -1,292 +0,0 @@
-"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 promises_exports = {};
-__export(promises_exports, {
-  fromAsync: () => fromAsync,
-  normalizeIterationOptions: () => normalizeIterationOptions,
-  normalizeRetryOptions: () => normalizeRetryOptions,
-  pEach: () => pEach,
-  pEachChunk: () => pEachChunk,
-  pFilter: () => pFilter,
-  pFilterChunk: () => pFilterChunk,
-  pRetry: () => pRetry,
-  resolveRetryOptions: () => resolveRetryOptions,
-  withResolvers: () => withResolvers
-});
-module.exports = __toCommonJS(promises_exports);
-var import_arrays = require("./arrays");
-var import_core = require("./constants/core");
-var import_process = require("./constants/process");
-var import_primordials = require("./primordials");
-const abortSignal = (0, import_process.getAbortSignal)();
-let _timers;
-// @__NO_SIDE_EFFECTS__
-function getTimers() {
-  if (_timers === void 0) {
-    _timers = require("node:timers/promises");
-  }
-  return _timers;
-}
-// @__NO_SIDE_EFFECTS__
-function normalizeIterationOptions(options) {
-  const opts = typeof options === "number" ? { concurrency: options } : options;
-  const {
-    // The number of concurrent executions performed at one time.
-    concurrency = 1,
-    // Retries as a number or options object.
-    retries,
-    // AbortSignal used to support cancellation.
-    signal = abortSignal
-  } = { __proto__: null, ...opts };
-  const normalizedConcurrency = (0, import_primordials.MathMax)(1, concurrency);
-  const retryOpts = /* @__PURE__ */ resolveRetryOptions(retries);
-  return {
-    __proto__: null,
-    concurrency: normalizedConcurrency,
-    retries: /* @__PURE__ */ normalizeRetryOptions({ signal, ...retryOpts }),
-    signal
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function normalizeRetryOptions(options) {
-  const resolved = /* @__PURE__ */ resolveRetryOptions(options);
-  const {
-    // Arguments to pass to the callback function.
-    args = [],
-    // Multiplier for exponential backoff (e.g., 2 doubles delay each retry).
-    backoffFactor = 2,
-    // Initial delay before the first retry (in milliseconds).
-    baseDelayMs = 200,
-    // Whether to apply randomness to spread out retries.
-    jitter = true,
-    // Upper limit for any backoff delay (in milliseconds).
-    maxDelayMs = 1e4,
-    // Optional callback invoked on each retry attempt:
-    // (attempt: number, error: unknown, delay: number) => void
-    onRetry,
-    // Whether onRetry can cancel retries by returning `false`.
-    onRetryCancelOnFalse = false,
-    // Whether onRetry will rethrow errors.
-    onRetryRethrow = false,
-    // Number of retry attempts (0 = no retries, only initial attempt).
-    retries = 0,
-    // AbortSignal used to support cancellation.
-    signal = abortSignal
-  } = resolved;
-  return {
-    args,
-    backoffFactor,
-    baseDelayMs,
-    jitter,
-    maxDelayMs,
-    onRetry,
-    onRetryCancelOnFalse,
-    onRetryRethrow,
-    retries,
-    signal
-  };
-}
-// @__NO_SIDE_EFFECTS__
-async function pEach(array, callbackFn, options) {
-  const iterOpts = /* @__PURE__ */ normalizeIterationOptions(options);
-  const { concurrency, retries, signal } = iterOpts;
-  const chunks = (0, import_arrays.arrayChunk)(array, concurrency);
-  for (const chunk of chunks) {
-    if (signal?.aborted) {
-      return;
-    }
-    await (0, import_primordials.PromiseAllSettled)(
-      chunk.map(
-        (item) => /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
-          ...retries,
-          args: [item],
-          signal
-        })
-      )
-    );
-  }
-}
-// @__NO_SIDE_EFFECTS__
-async function pEachChunk(array, callbackFn, options) {
-  const { chunkSize = 100, ...retryOpts } = options || {};
-  const chunks = (0, import_arrays.arrayChunk)(array, chunkSize);
-  const normalizedRetryOpts = /* @__PURE__ */ normalizeRetryOptions(retryOpts);
-  const { signal } = normalizedRetryOpts;
-  for (const chunk of chunks) {
-    if (signal?.aborted) {
-      return;
-    }
-    await /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
-      ...normalizedRetryOpts,
-      args: [chunk]
-    });
-  }
-}
-// @__NO_SIDE_EFFECTS__
-async function pFilter(array, callbackFn, options) {
-  const iterOpts = /* @__PURE__ */ normalizeIterationOptions(options);
-  return (await /* @__PURE__ */ pFilterChunk(
-    (0, import_arrays.arrayChunk)(array, iterOpts.concurrency),
-    callbackFn,
-    iterOpts.retries
-  )).flat();
-}
-// @__NO_SIDE_EFFECTS__
-async function pFilterChunk(chunks, callbackFn, options) {
-  const retryOpts = /* @__PURE__ */ normalizeRetryOptions(options);
-  const { signal } = retryOpts;
-  const { length } = chunks;
-  const filteredChunks = Array(length);
-  for (let i = 0; i < length; i += 1) {
-    if (signal?.aborted) {
-      filteredChunks[i] = [];
-    } else {
-      const chunk = chunks[i];
-      const settled = await (0, import_primordials.PromiseAllSettled)(
-        chunk.map(
-          (value) => /* @__PURE__ */ pRetry((...args) => callbackFn(args[0]), {
-            ...retryOpts,
-            args: [value]
-          })
-        )
-      );
-      const predicateResults = settled.map(
-        (r) => r.status === "fulfilled" ? r.value : false
-      );
-      filteredChunks[i] = chunk.filter((_v, i2) => predicateResults[i2]);
-    }
-  }
-  return filteredChunks;
-}
-// @__NO_SIDE_EFFECTS__
-async function pRetry(callbackFn, options) {
-  const {
-    args,
-    backoffFactor,
-    baseDelayMs,
-    jitter,
-    maxDelayMs,
-    onRetry,
-    onRetryCancelOnFalse,
-    onRetryRethrow,
-    retries,
-    signal
-  } = /* @__PURE__ */ normalizeRetryOptions(options);
-  if (signal?.aborted) {
-    return void 0;
-  }
-  if (retries === 0) {
-    return await callbackFn(...args || [], { signal });
-  }
-  const timers = /* @__PURE__ */ getTimers();
-  let attempts = retries;
-  let delay = baseDelayMs;
-  let error = import_core.UNDEFINED_TOKEN;
-  while (attempts-- >= 0) {
-    if (signal?.aborted) {
-      return void 0;
-    }
-    try {
-      return await callbackFn(...args || [], { signal });
-    } catch (e) {
-      error = e;
-      if (attempts < 0) {
-        break;
-      }
-      let waitTime = delay;
-      if (jitter) {
-        waitTime += (0, import_primordials.MathFloor)((0, import_primordials.MathRandom)() * delay);
-      }
-      waitTime = (0, import_primordials.MathMin)(waitTime, maxDelayMs);
-      if (typeof onRetry === "function") {
-        try {
-          const result = onRetry(retries - attempts, e, waitTime);
-          if (result === false && onRetryCancelOnFalse) {
-            break;
-          }
-          if (typeof result === "number" && result >= 0) {
-            waitTime = (0, import_primordials.MathMin)(result, maxDelayMs);
-          }
-        } catch (e2) {
-          if (onRetryRethrow) {
-            throw e2;
-          }
-        }
-      }
-      try {
-        await timers.setTimeout(waitTime, void 0, { signal });
-      } catch {
-        return void 0;
-      }
-      if (signal?.aborted) {
-        return void 0;
-      }
-      delay = (0, import_primordials.MathMin)(delay * backoffFactor, maxDelayMs);
-    }
-  }
-  if (error !== import_core.UNDEFINED_TOKEN) {
-    throw error;
-  }
-  return void 0;
-}
-// @__NO_SIDE_EFFECTS__
-function resolveRetryOptions(options) {
-  const defaults = {
-    __proto__: null,
-    retries: 0,
-    baseDelayMs: 200,
-    maxDelayMs: 1e4,
-    backoffFactor: 2
-  };
-  if (typeof options === "number") {
-    return { ...defaults, retries: options };
-  }
-  return options ? { ...defaults, ...options } : defaults;
-}
-const withResolvers = import_primordials.PromiseWithResolvers !== void 0 ? import_primordials.PromiseWithResolvers : () => {
-  let resolve;
-  let reject;
-  const promise = new import_primordials.PromiseCtor((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-};
-const fromAsync = import_primordials.ArrayFromAsync !== void 0 ? import_primordials.ArrayFromAsync : async (source) => {
-  const out = [];
-  for await (const item of source) {
-    out.push(item);
-  }
-  return out;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fromAsync,
-  normalizeIterationOptions,
-  normalizeRetryOptions,
-  pEach,
-  pEachChunk,
-  pFilter,
-  pFilterChunk,
-  pRetry,
-  resolveRetryOptions,
-  withResolvers
-});

package/dist/regexps.d.ts

@@ -1,6 +0,0 @@
-/**
- * @fileoverview Regular expression utilities including a spec-compliant
- * `RegExp.escape` fallback. Provides regex escaping and pattern matching
- * helpers.
- */
-export declare const escapeRegExp: (str: string) => string;

package/dist/releases/github-api.d.ts

@@ -1,56 +0,0 @@
-/**
- * @fileoverview GitHub release listing + asset-URL discovery.
- *
- * REST is the canonical path; we fall back to GraphQL when GitHub's
- * Elasticsearch listing index is degraded (200 OK + empty body). Both
- * transports normalize to the same internal `ReleaseRow` shape so the
- * filtering pipeline doesn't care which transport produced the data.
- */
-import type { AssetPattern, RepoConfig } from './github-types';
-/**
- * Get latest release tag matching a tool prefix.
- * Optionally filter by releases containing a matching asset.
- *
- * @param toolPrefix - Tool name prefix to search for (e.g., 'node-smol-')
- * @param repoConfig - Repository configuration (owner/repo)
- * @param options - Additional options
- * @param options.assetPattern - Optional pattern to filter releases by matching asset
- * @param options.nothrow - If true, return undefined instead of throwing when both REST and GraphQL backends are degraded. Default: false.
- * @returns Latest release tag or undefined if not found
- * @throws {Error} If both REST and GraphQL backends are degraded and nothrow is false.
- *
- * @example
- * ```typescript
- * const tag = await getLatestRelease('lief-', {
- *   owner: 'SocketDev', repo: 'socket-btm',
- * })
- * console.log(tag) // 'lief-2025-01-15-abc1234'
- * ```
- */
-export declare function getLatestRelease(toolPrefix: string, repoConfig: RepoConfig, options?: {
-    assetPattern?: AssetPattern;
-    nothrow?: boolean;
-}): Promise<string | undefined>;
-/**
- * Get download URL for a specific release asset.
- * Supports pattern matching for dynamic asset discovery.
- *
- * @param tag - Release tag name
- * @param assetPattern - Asset name or pattern (glob string, prefix/suffix object, or RegExp)
- * @param repoConfig - Repository configuration (owner/repo)
- * @param options - Additional options
- * @param options.nothrow - If true, return undefined instead of throwing when both REST and GraphQL backends are degraded. Default: false.
- * @returns Browser download URL for the asset, or undefined when not found.
- * @throws {Error} If both REST and GraphQL backends are degraded and nothrow is false.
- *
- * @example
- * ```typescript
- * const url = await getReleaseAssetUrl(
- *   'v1.0.0', 'tool-linux-x64',
- *   { owner: 'SocketDev', repo: 'socket-btm' },
- * )
- * ```
- */
-export declare function getReleaseAssetUrl(tag: string, assetPattern: string | AssetPattern, repoConfig: RepoConfig, options?: {
-    nothrow?: boolean;
-}): Promise<string | undefined>;

package/dist/releases/github-api.js

@@ -1,275 +0,0 @@
-"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 github_api_exports = {};
-__export(github_api_exports, {
-  getLatestRelease: () => getLatestRelease,
-  getReleaseAssetUrl: () => getReleaseAssetUrl
-});
-module.exports = __toCommonJS(github_api_exports);
-var import_http_request = require("../http-request");
-var import_primordials = require("../primordials");
-var import_promises = require("../promises");
-var import_github_assets = require("./github-assets");
-var import_github_auth = require("./github-auth");
-const RETRY_CONFIG = (0, import_primordials.ObjectFreeze)({
-  __proto__: null,
-  // Exponential backoff: delay doubles with each retry (5s, 10s, 20s).
-  backoffFactor: 2,
-  // Initial delay before first retry.
-  baseDelayMs: 5e3,
-  // Maximum number of retry attempts (excluding initial request).
-  retries: 2
-});
-async function fetchReleasesViaRest(owner, repo) {
-  const response = await (0, import_http_request.httpRequest)(
-    `https://api.github.com/repos/${owner}/${repo}/releases?per_page=100`,
-    { headers: (0, import_github_auth.getAuthHeaders)() }
-  );
-  if (!response.ok) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to fetch ${owner}/${repo} releases: ${response.status}`
-    );
-  }
-  const text = response.body.toString("utf8");
-  if (text.length === 0) {
-    return [];
-  }
-  let parsed;
-  try {
-    parsed = (0, import_primordials.JSONParse)(text);
-  } catch (cause) {
-    throw new import_primordials.ErrorCtor(`Failed to parse ${owner}/${repo} releases response`, {
-      cause
-    });
-  }
-  return (0, import_primordials.ArrayIsArray)(parsed) ? parsed : [];
-}
-async function fetchReleasesViaGraphQL(owner, repo) {
-  const response = await (0, import_http_request.httpRequest)("https://api.github.com/graphql", {
-    body: (0, import_primordials.JSONStringify)({
-      query: `query($owner: String!, $repo: String!) {
-        repository(owner: $owner, name: $repo) {
-          releases(first: 100, orderBy: {field: CREATED_AT, direction: DESC}) {
-            nodes {
-              tagName
-              publishedAt
-              releaseAssets(first: 100) { nodes { name } }
-            }
-          }
-        }
-      }`,
-      variables: { owner, repo }
-    }),
-    headers: { ...(0, import_github_auth.getAuthHeaders)(), "Content-Type": "application/json" },
-    method: "POST"
-  });
-  if (!response.ok) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to fetch ${owner}/${repo} releases (GraphQL): ${response.status}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = (0, import_primordials.JSONParse)(response.body.toString("utf8"));
-  } catch (cause) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to parse GitHub GraphQL response for ${owner}/${repo} releases`,
-      { cause }
-    );
-  }
-  if (parsed.errors?.length) {
-    throw new import_primordials.ErrorCtor(
-      `GraphQL repository.releases(${owner}/${repo}) returned errors: ${parsed.errors.map((e) => e.message).join("; ")}`
-    );
-  }
-  return (parsed.data?.repository?.releases?.nodes ?? []).map((n) => ({
-    tag_name: n.tagName,
-    published_at: n.publishedAt,
-    assets: n.releaseAssets?.nodes ?? []
-  }));
-}
-async function fetchReleaseAssetsViaGraphQL(owner, repo, tag) {
-  const response = await (0, import_http_request.httpRequest)("https://api.github.com/graphql", {
-    body: (0, import_primordials.JSONStringify)({
-      query: `query($owner: String!, $repo: String!, $tag: String!) {
-        repository(owner: $owner, name: $repo) {
-          release(tagName: $tag) {
-            tagName
-            releaseAssets(first: 100) { nodes { name downloadUrl } }
-          }
-        }
-      }`,
-      variables: { owner, repo, tag }
-    }),
-    headers: { ...(0, import_github_auth.getAuthHeaders)(), "Content-Type": "application/json" },
-    method: "POST"
-  });
-  if (!response.ok) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to fetch ${owner}/${repo} release ${tag} (GraphQL): ${response.status} ${response.statusText}`
-    );
-  }
-  if (response.body.byteLength === 0) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to fetch ${owner}/${repo} release ${tag}: GraphQL returned empty body`
-    );
-  }
-  let parsed;
-  try {
-    parsed = (0, import_primordials.JSONParse)(response.body.toString("utf8"));
-  } catch (cause) {
-    throw new import_primordials.ErrorCtor(
-      `Failed to parse ${owner}/${repo} release ${tag} response (GraphQL)`,
-      { cause }
-    );
-  }
-  if (parsed.errors?.length) {
-    throw new import_primordials.ErrorCtor(
-      `GraphQL repository.release(${owner}/${repo}, ${tag}) returned errors: ${parsed.errors.map((e) => e.message).join("; ")}`
-    );
-  }
-  const release = parsed.data?.repository?.release;
-  if (!release) {
-    return void 0;
-  }
-  return (release.releaseAssets?.nodes ?? []).map((n) => ({
-    browser_download_url: n.downloadUrl,
-    name: n.name
-  }));
-}
-async function getLatestRelease(toolPrefix, repoConfig, options = {}) {
-  const { assetPattern, nothrow = false } = options;
-  const { owner, repo } = repoConfig;
-  const isMatch = assetPattern ? (0, import_github_assets.createAssetMatcher)(assetPattern) : void 0;
-  return await (0, import_promises.pRetry)(async () => {
-    let releases = await fetchReleasesViaRest(owner, repo);
-    if (releases.length === 0) {
-      let graphqlReleases;
-      try {
-        graphqlReleases = await fetchReleasesViaGraphQL(owner, repo);
-      } catch (cause) {
-        if (nothrow) {
-          return void 0;
-        }
-        throw new import_primordials.ErrorCtor(
-          `Failed to list ${owner}/${repo} releases: both REST and GraphQL backends degraded`,
-          { cause }
-        );
-      }
-      if (graphqlReleases.length > 0) {
-        releases = graphqlReleases;
-      }
-    }
-    const matchingReleases = releases.filter((release) => {
-      const { assets, tag_name: tag } = release;
-      if (!(0, import_primordials.StringPrototypeStartsWith)(tag, toolPrefix)) {
-        return false;
-      }
-      if (!assets || assets.length === 0) {
-        return false;
-      }
-      if (isMatch) {
-        const hasMatchingAsset = assets.some(
-          (a) => isMatch(a.name)
-        );
-        if (!hasMatchingAsset) {
-          return false;
-        }
-      }
-      return true;
-    });
-    if (matchingReleases.length === 0) {
-      return void 0;
-    }
-    matchingReleases.sort(
-      (a, b) => (0, import_primordials.DateParse)(b.published_at) - (0, import_primordials.DateParse)(a.published_at)
-    );
-    const latestRelease = matchingReleases[0];
-    return latestRelease.tag_name;
-  }, RETRY_CONFIG) ?? void 0;
-}
-async function getReleaseAssetUrl(tag, assetPattern, repoConfig, options = {}) {
-  const { nothrow = false } = options;
-  const { owner, repo } = repoConfig;
-  const isMatch = typeof assetPattern === "string" && !assetPattern.includes("*") && !assetPattern.includes("{") ? (input) => input === assetPattern : (0, import_github_assets.createAssetMatcher)(assetPattern);
-  return await (0, import_promises.pRetry)(async () => {
-    const response = await (0, import_http_request.httpRequest)(
-      `https://api.github.com/repos/${owner}/${repo}/releases/tags/${tag}`,
-      {
-        headers: (0, import_github_auth.getAuthHeaders)()
-      }
-    );
-    if (!response.ok) {
-      throw new import_primordials.ErrorCtor(
-        `Failed to fetch ${owner}/${repo} release ${tag}: ${response.status}`
-      );
-    }
-    let assets;
-    if (response.body.byteLength === 0) {
-      let fallbackAssets;
-      try {
-        fallbackAssets = await fetchReleaseAssetsViaGraphQL(owner, repo, tag);
-      } catch (cause) {
-        if (nothrow) {
-          return void 0;
-        }
-        throw new import_primordials.ErrorCtor(
-          `Failed to fetch ${owner}/${repo} release ${tag}: both REST and GraphQL backends degraded`,
-          { cause }
-        );
-      }
-      if (fallbackAssets === void 0) {
-        if (nothrow) {
-          return void 0;
-        }
-        throw new import_primordials.ErrorCtor(`Release ${tag} not found in ${owner}/${repo}`);
-      }
-      assets = fallbackAssets;
-    } else {
-      let release;
-      try {
-        release = (0, import_primordials.JSONParse)(response.body.toString("utf8"));
-      } catch (cause) {
-        throw new import_primordials.ErrorCtor(
-          `Failed to parse ${owner}/${repo} release ${tag} response`,
-          { cause }
-        );
-      }
-      if (!(0, import_primordials.ArrayIsArray)(release.assets)) {
-        throw new import_primordials.ErrorCtor(
-          `Release ${tag} has no assets in ${owner}/${repo}`
-        );
-      }
-      assets = release.assets;
-    }
-    const asset = assets.find((a) => isMatch(a.name));
-    if (!asset) {
-      const patternDesc = typeof assetPattern === "string" ? assetPattern : "matching pattern";
-      throw new import_primordials.ErrorCtor(`Asset ${patternDesc} not found in release ${tag}`);
-    }
-    return asset.browser_download_url;
-  }, RETRY_CONFIG) ?? void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getLatestRelease,
-  getReleaseAssetUrl
-});

package/dist/sea/util.d.ts

@@ -1,43 +0,0 @@
-/**
- * @fileoverview SEA (Single Executable Application) binary detection +
- * path accessor.
- *
- * Two responsibilities (mirror of `src/smol/util.ts` shape):
- *
- *   1. `isSeaBinary()` — memoized boolean detector for whether the
- *      current process is running as a Node.js Single Executable
- *      Application. Probes via Node 24+'s `node:sea.isSea()` native
- *      API; falls back to `false` on older runtimes.
- *
- *   2. `getSeaBinaryPath()` — returns the path of the SEA binary
- *      (`process.argv[0]` normalized) when running as SEA, otherwise
- *      `undefined`.
- *
- * Defensive across runtimes: returns `false` / `undefined` cleanly on
- * stock Node < 24, browsers, Deno, Bun.
- */
-/**
- * Detect if the current process is running as a SEA binary.
- * Uses Node.js 24+ native API with caching for performance.
- *
- * @example
- * ```typescript
- * if (isSeaBinary()) {
- *   console.log('Running as a Single Executable Application')
- * }
- * ```
- */
-export declare function isSeaBinary(): boolean;
-/**
- * Get the current SEA binary path.
- * Only valid when running as a SEA binary.
- *
- * @example
- * ```typescript
- * const binPath = getSeaBinaryPath()
- * if (binPath) {
- *   console.log(`Running as SEA binary: ${binPath}`)
- * }
- * ```
- */
-export declare function getSeaBinaryPath(): string | undefined;

package/dist/shadow.d.ts

@@ -1,28 +0,0 @@
-/**
- * @fileoverview Shadow binary installation utilities for Socket ecosystem.
- * Provides logic to determine when shadow binary installation should be skipped.
- */
-export interface ShadowInstallationOptions {
-    cwd?: string | undefined;
-    win32?: boolean | undefined;
-}
-/**
- * Determines if shadow binaries should be installed.
- * Shadows should NOT be installed when:
- * - Running in a temporary execution context (exec/npx/dlx)
- * - On Windows with an existing binary path (required for Windows to function)
- *
- * @param binPath - Path to the binary being shadowed
- * @param options - Configuration options
- * @param options.cwd - Current working directory path to check
- * @param options.win32 - Whether running on Windows
- * @returns true if shadow installation should be skipped
- *
- * @example
- * ```typescript
- * if (shouldSkipShadow(binPath, { cwd: process.cwd() })) {
- *   console.log('Skipping shadow binary installation')
- * }
- * ```
- */
-export declare function shouldSkipShadow(binPath: string, options?: ShadowInstallationOptions | undefined): boolean;