@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/dlx/manifest.js

@@ -26,31 +26,20 @@ __export(manifest_exports, {
   isPackageEntry: () => isPackageEntry
 });
 module.exports = __toCommonJS(manifest_exports);
-var import_errors = require("../errors");
-var import_fs = require("../fs");
-var import_logger = require("../logger");
+var import_message = require("../errors/message");
+var import_read_file = require("../fs/read-file");
+var import_safe = require("../fs/safe");
+var import_default = require("../logger/default");
 var import_socket = require("../paths/socket");
-var import_process_lock = require("../process-lock");
-var import_primordials = require("../primordials");
-let _fs;
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-const fs = /* @__PURE__ */ getFs();
-const path = /* @__PURE__ */ getPath();
-const logger = (0, import_logger.getDefaultLogger)();
+var import_lock_instance = require("../process/lock-instance");
+var import_date = require("../primordials/date");
+var import_json = require("../primordials/json");
+var import_object = require("../primordials/object");
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
+const fs = (0, import_fs.getNodeFs)();
+const path = (0, import_path.getNodePath)();
+const logger = (0, import_default.getDefaultLogger)();
 const MANIFEST_FILE_NAME = ".dlx-manifest.json";
 function isBinaryEntry(entry) {
   return entry.type === "binary";
@@ -67,6 +56,7 @@ class DlxManifest {
   }
   /**
    * Read the entire manifest file.
+   *
    * @private
    */
   readManifest() {
@@ -74,29 +64,33 @@ class DlxManifest {
       if (!fs.existsSync(this.manifestPath)) {
         return { __proto__: null };
       }
-      const rawContent = (0, import_fs.readFileUtf8Sync)(this.manifestPath);
-      const content = (typeof rawContent === "string" ? rawContent : rawContent.toString("utf8")).trim();
+      const rawContent = (0, import_read_file.readFileUtf8Sync)(this.manifestPath);
+      const content = (typeof rawContent === "string" ? rawContent : (
+        /* c8 ignore next - readFileUtf8Sync returns string in tests; Buffer fallback. */
+        rawContent.toString("utf8")
+      )).trim();
       if (!content) {
         return { __proto__: null };
       }
-      return (0, import_primordials.JSONParse)(content);
+      return (0, import_json.JSONParse)(content);
     } catch (e) {
-      logger.warn(`Failed to read manifest: ${(0, import_errors.errorMessage)(e)}`);
+      logger.warn(`Failed to read manifest: ${(0, import_message.errorMessage)(e)}`);
       return { __proto__: null };
     }
   }
   /**
    * Write the manifest file atomically.
+   *
    * @private
    */
   async writeManifest(data) {
     const manifestDir = path.dirname(this.manifestPath);
     try {
-      (0, import_fs.safeMkdirSync)(manifestDir, { recursive: true });
+      (0, import_safe.safeMkdirSync)(manifestDir, { recursive: true });
     } catch (e) {
-      logger.warn(`Failed to create manifest directory: ${(0, import_errors.errorMessage)(e)}`);
+      logger.warn(`Failed to create manifest directory: ${(0, import_message.errorMessage)(e)}`);
     }
-    const content = (0, import_primordials.JSONStringify)(data, null, 2);
+    const content = (0, import_json.JSONStringify)(data, void 0, 2);
     const tempPath = `${this.manifestPath}.tmp`;
     try {
       fs.writeFileSync(tempPath, content, "utf8");
@@ -104,7 +98,7 @@ class DlxManifest {
     } catch (e) {
       try {
         if (fs.existsSync(tempPath)) {
-          fs.unlinkSync(tempPath);
+          (0, import_safe.safeDeleteSync)(tempPath);
         }
       } catch {
       }
@@ -115,7 +109,7 @@ class DlxManifest {
    * Clear cached data for a specific entry.
    */
   async clear(name) {
-    await import_process_lock.processLock.withLock(this.lockPath, async () => {
+    await import_lock_instance.processLock.withLock(this.lockPath, async () => {
       try {
         if (!fs.existsSync(this.manifestPath)) {
           return;
@@ -124,11 +118,11 @@ class DlxManifest {
         if (!content.trim()) {
           return;
         }
-        const data = JSON.parse(content);
+        const data = (0, import_json.JSONParse)(content);
         delete data[name];
         await this.writeManifest(data);
       } catch (e) {
-        logger.warn(`Failed to clear cache for ${name}: ${(0, import_errors.errorMessage)(e)}`);
+        logger.warn(`Failed to clear cache for ${name}: ${(0, import_message.errorMessage)(e)}`);
       }
     });
   }
@@ -136,18 +130,19 @@ class DlxManifest {
    * Clear all cached data.
    */
   async clearAll() {
-    await import_process_lock.processLock.withLock(this.lockPath, async () => {
+    await import_lock_instance.processLock.withLock(this.lockPath, async () => {
       try {
         if (fs.existsSync(this.manifestPath)) {
-          fs.unlinkSync(this.manifestPath);
+          (0, import_safe.safeDeleteSync)(this.manifestPath);
         }
       } catch (e) {
-        logger.warn(`Failed to clear all cache: ${(0, import_errors.errorMessage)(e)}`);
+        logger.warn(`Failed to clear all cache: ${(0, import_message.errorMessage)(e)}`);
       }
     });
   }
   /**
    * Get cached update information for a package (legacy format).
+   *
    * @deprecated Use getManifestEntry() for new code.
    */
   get(name) {
@@ -166,15 +161,18 @@ class DlxManifest {
       if (!fs.existsSync(this.manifestPath)) {
         return [];
       }
-      const rawContent = (0, import_fs.readFileUtf8Sync)(this.manifestPath);
-      const content = (typeof rawContent === "string" ? rawContent : rawContent.toString("utf8")).trim();
+      const rawContent = (0, import_read_file.readFileUtf8Sync)(this.manifestPath);
+      const content = (typeof rawContent === "string" ? rawContent : (
+        /* c8 ignore next - readFileUtf8Sync returns string in tests; Buffer fallback. */
+        rawContent.toString("utf8")
+      )).trim();
       if (!content) {
         return [];
       }
-      const data = (0, import_primordials.JSONParse)(content);
-      return (0, import_primordials.ObjectKeys)(data);
+      const data = (0, import_json.JSONParse)(content);
+      return (0, import_object.ObjectKeys)(data);
     } catch (e) {
-      logger.warn(`Failed to get package list: ${(0, import_errors.errorMessage)(e)}`);
+      logger.warn(`Failed to get package list: ${(0, import_message.errorMessage)(e)}`);
       return [];
     }
   }
@@ -196,15 +194,16 @@ class DlxManifest {
     if (!record) {
       return false;
     }
-    const age = (0, import_primordials.DateNow)() - record.timestampFetch;
+    const age = (0, import_date.DateNow)() - record.timestampFetch;
     return age < ttlMs;
   }
   /**
    * Store update information for a package (legacy format).
+   *
    * @deprecated Use setPackageEntry() for new code.
    */
   async set(name, record) {
-    await import_process_lock.processLock.withLock(this.lockPath, async () => {
+    await import_lock_instance.processLock.withLock(this.lockPath, async () => {
       let data = {
         __proto__: null
       };
@@ -212,20 +211,20 @@ class DlxManifest {
         if (fs.existsSync(this.manifestPath)) {
           const content2 = fs.readFileSync(this.manifestPath, "utf8");
           if (content2.trim()) {
-            data = JSON.parse(content2);
+            data = (0, import_json.JSONParse)(content2);
           }
         }
       } catch (e) {
-        logger.warn(`Failed to read existing manifest: ${(0, import_errors.errorMessage)(e)}`);
+        logger.warn(`Failed to read existing manifest: ${(0, import_message.errorMessage)(e)}`);
       }
       data[name] = record;
       const manifestDir = path.dirname(this.manifestPath);
       try {
-        (0, import_fs.safeMkdirSync)(manifestDir, { recursive: true });
+        (0, import_safe.safeMkdirSync)(manifestDir, { recursive: true });
       } catch (e) {
-        logger.warn(`Failed to create manifest directory: ${(0, import_errors.errorMessage)(e)}`);
+        logger.warn(`Failed to create manifest directory: ${(0, import_message.errorMessage)(e)}`);
       }
-      const content = JSON.stringify(data, null, 2);
+      const content = (0, import_json.JSONStringify)(data, null, 2);
       const tempPath = `${this.manifestPath}.tmp`;
       try {
         fs.writeFileSync(tempPath, content, "utf8");
@@ -233,7 +232,7 @@ class DlxManifest {
       } catch (e) {
         try {
           if (fs.existsSync(tempPath)) {
-            fs.unlinkSync(tempPath);
+            (0, import_safe.safeDeleteSync)(tempPath);
           }
         } catch {
         }
@@ -245,7 +244,7 @@ class DlxManifest {
    * Set a binary manifest entry.
    */
   async setBinaryEntry(spec, cacheKey, details) {
-    await import_process_lock.processLock.withLock(this.lockPath, async () => {
+    await import_lock_instance.processLock.withLock(this.lockPath, async () => {
       const data = this.readManifest();
       data[spec] = {
         type: "binary",
@@ -260,7 +259,7 @@ class DlxManifest {
    * Set a package manifest entry.
    */
   async setPackageEntry(spec, cacheKey, details) {
-    await import_process_lock.processLock.withLock(this.lockPath, async () => {
+    await import_lock_instance.processLock.withLock(this.lockPath, async () => {
       const data = this.readManifest();
       data[spec] = {
         type: "package",

package/dist/dlx/package.d.ts

@@ -1,311 +1,115 @@
 /**
- * @fileoverview DLX package execution - Install and execute npm packages.
- *
- * This module provides functionality to install and execute npm packages
- * in the ~/.socket/_dlx directory, similar to npx but with Socket's own cache.
- *
- * Uses content-addressed storage like npm's _npx:
- * - Hash is generated from package spec (name@version)
- * - Each unique spec gets its own directory: ~/.socket/_dlx/<hash>/
- * - Allows caching multiple versions of the same package
- *
- * Concurrency protection:
- * - Uses process-lock to prevent concurrent installation corruption
- * - Lock file created at ~/.socket/_dlx/<hash>/concurrency.lock
- * - Uses npm npx's concurrency.lock naming convention (5s stale, 2s touching)
- * - Prevents multiple processes from corrupting the same package installation
- *
- * Version range handling:
- * - Exact versions (1.0.0) use cache if available
- * - Range versions (^1.0.0, ~1.0.0) auto-force to get latest within range
- * - User can override with explicit force: false
- *
- * Key difference from dlx-binary.ts:
- * - dlx-binary.ts: Downloads standalone binaries from URLs
- * - dlx-package.ts: Installs npm packages from registries
- *
- * Implementation:
- * - Uses Arborist for package installation (like npx, no npm CLI required)
- * - Split into downloadPackage() and executePackage() for flexibility
- * - dlxPackage() combines both for convenience
- */
-import { spawn } from '../spawn';
-import type { HashSpec } from './integrity';
-import type { LockfileSpec } from './lockfile';
-import type { SpawnExtra, SpawnOptions } from '../spawn';
-export interface DownloadPackageResult {
-    /** Path to the installed package directory. */
-    packageDir: string;
-    /** Path to the binary. */
-    binaryPath: string;
-    /** Whether the package was newly installed. */
-    installed: boolean;
-}
-/**
- * Shared install-pinning options used by both {@link DlxPackageOptions}
- * and the lower-level {@link ensurePackageInstalled}.
+ * @file DLX package execution — install and execute npm packages. This module
+ *   provides functionality to install and execute npm packages in the
+ *   ~/.socket/_dlx directory, similar to npx but with Socket's own cache. Uses
+ *   content-addressed storage like npm's _npx:
+ *
+ *   - Hash is generated from package spec (name@version)
+ *   - Each unique spec gets its own directory: ~/.socket/_dlx/<hash>/
+ *   - Allows caching multiple versions of the same package Concurrency
+ *     protection:
+ *   - Uses process-lock to prevent concurrent installation corruption
+ *   - Lock file created at ~/.socket/_dlx/<hash>/concurrency.lock
+ *   - Uses npm npx's concurrency.lock naming convention (5s stale, 2s touching)
+ *   - Prevents multiple processes from corrupting the same package installation
+ *     Version range handling:
+ *   - Exact versions (1.0.0) use cache if available
+ *   - Range versions (^1.0.0, ~1.0.0) auto-force to get latest within range
+ *   - User can override with explicit force: false Key difference from
+ *     dlx/binary.ts:
+ *   - dlx/binary.ts: Downloads standalone binaries from URLs
+ *   - dlx/package.ts: Installs npm packages from registries Implementation:
+ *   - Uses Arborist for package installation (like npx, no npm CLI required)
+ *   - Split into downloadPackage() and executePackage() for flexibility
+ *   - dlxPackage() combines both for convenience Module shape: this file holds
+ *     the three async orchestrators (`dlxPackage`, `downloadPackage`,
+ *     `ensurePackageInstalled`) and the synchronous `executePackage`. The
+ *     supporting surface lives in sibling leaves and is re-exported here so
+ *     existing `dlx/package` importers keep working unchanged:
+ *   - types — `./types`
+ *   - PURL + firewall — `./firewall`
+ *   - spec parsing — `./spec`
+ *   - binary resolution — `./binary-resolution`
+ *   - lazy `node:fs` / `node:path` + LRU cache — `./_internal`
  */
-export interface EnsurePackageInstallOptions {
-    /**
-     * Expected hash of the top-level package tarball. Accepts either:
-     * - A bare sha512 SRI string (sniffed as integrity).
-     * - A bare sha256 hex string (sniffed as checksum).
-     * - An explicit `{ type: 'integrity' | 'checksum', value }` object.
-     */
-    hash?: HashSpec | undefined;
-    /**
-     * Override the install root passed to Arborist. By default, the
-     * install root is `~/.socket/_dlx/<cacheKey>/` (or
-     * `SOCKET_DLX_DIR/<cacheKey>/`) — keyed by spec so multiple specs
-     * share a parent dir without colliding. When `installRoot` is set,
-     * the install root is the value verbatim — no cacheKey subdirectory.
-     *
-     * In both cases the package itself lands at
-     * `<installRoot>/node_modules/<packageName>/` with transitive deps as
-     * siblings under the same `node_modules/` directory. That layout is a
-     * fixed property of Arborist; this option only controls the parent.
-     *
-     * That means **the caller is responsible for keeping per-spec
-     * installs separated** — calling twice with the same `installRoot`
-     * but different specs (e.g. `ink@7` and `ink@8`) overwrites the
-     * earlier install. Either pass a different `installRoot` per spec or
-     * pass `force: true` to accept the overwrite.
-     *
-     * Pass a sentinel name (e.g. `_dlx`, `_pkg`, `vendor`) — never one
-     * that ends in `node_modules`, since that turns the install root
-     * into something parent-walking resolvers, IDE indexers, and pnpm
-     * hoisting will mistake for a workspace `node_modules/`.
-     *
-     * Use cases:
-     * - Build pipelines that want the install gitignored alongside their
-     *   own outputs and walkable by tools that resolve through
-     *   `node_modules` (e.g. esbuild's `nodePaths`).
-     * - Tests that need a deterministic, easily-cleaned install path.
-     */
-    installRoot?: string | undefined;
-    /**
-     * Vendored `package-lock.json` to drive a reproducible install. Accepts
-     * a filesystem path (sniffed) or raw JSON content (sniffed via leading
-     * `{`), or an explicit `{ type: 'path' | 'content', value }` object.
-     *
-     * When provided, the lockfile is written into the install dir before
-     * Arborist runs and a hardened `.npmrc` is placed alongside it.
-     */
-    lockfile?: LockfileSpec | undefined;
-}
-export interface DlxPackageOptions extends EnsurePackageInstallOptions {
-    /**
-     * Package to install (e.g., '@cyclonedx/cdxgen@10.0.0').
-     * Aligns with npx --package flag.
-     */
-    package: string;
-    /**
-     * Binary name to execute (optional - auto-detected in most cases).
-     *
-     * Auto-detection logic:
-     * 1. If package has only one binary, uses it automatically
-     * 2. Tries user-provided binaryName
-     * 3. Tries last segment of package name (e.g., 'cli' from '@socketsecurity/cli')
-     * 4. Falls back to first binary
-     *
-     * Only needed when package has multiple binaries and auto-detection fails.
-     *
-     * @example
-     * // Auto-detected (single binary)
-     * { package: '@socketsecurity/cli' }  // Finds 'socket' binary automatically
-     *
-     * // Explicit (multiple binaries)
-     * { package: 'some-tool', binaryName: 'specific-tool' }
-     */
-    binaryName?: string | undefined;
-    /**
-     * Force reinstallation even if package exists.
-     * Aligns with npx --yes/-y flag behavior.
-     */
-    force?: boolean | undefined;
-    /**
-     * Skip confirmation prompts (auto-approve).
-     * Aligns with npx --yes/-y flag.
-     */
-    yes?: boolean | undefined;
-    /**
-     * Suppress output (quiet mode).
-     * Aligns with npx --quiet/-q and pnpm --silent/-s flags.
-     */
-    quiet?: boolean | undefined;
-    /**
-     * Additional spawn options for the execution.
-     */
-    spawnOptions?: SpawnOptions | undefined;
-}
-export interface DlxPackageResult {
-    /** Path to the installed package directory. */
-    packageDir: string;
-    /** Path to the binary that was executed. */
-    binaryPath: string;
-    /** Whether the package was newly installed. */
-    installed: boolean;
-    /** The spawn promise for the running process. */
-    spawnPromise: ReturnType<typeof spawn>;
-}
+import { spawn } from '../process/spawn/child';
+import type { DlxPackageOptions, DlxPackageResult, DownloadPackageResult, EnsurePackageInstallOptions } from './types';
+import type { SpawnExtra, SpawnOptions } from '../process/spawn/types';
 /**
  * Execute a package via DLX - install if needed and run its binary.
  *
- * This is the Socket equivalent of npx/pnpm dlx/yarn dlx, but using
- * our own cache directory (~/.socket/_dlx) and installation logic.
+ * This is the Socket equivalent of npx/pnpm dlx/yarn dlx, but using our own
+ * cache directory (~/.socket/_dlx) and installation logic.
  *
  * Auto-forces reinstall for version ranges to get latest within range.
  *
  * @example
- * ```typescript
- * // Download and execute cdxgen
- * const result = await dlxPackage(
- *   ['--version'],
- *   { package: '@cyclonedx/cdxgen@10.0.0' }
- * )
- * await result.spawnPromise
- * ```
+ *   ;```typescript
+ *   // Download and execute cdxgen
+ *   const result = await dlxPackage(['--version'], {
+ *     package: '@cyclonedx/cdxgen@10.0.0',
+ *   })
+ *   await result.spawnPromise
+ *   ```
  */
 export declare function dlxPackage(args: readonly string[] | string[], options: DlxPackageOptions, spawnExtra?: SpawnExtra | undefined): Promise<DlxPackageResult>;
 /**
- * Download and install a package without executing it.
- * This is useful for self-update or when you need the package files
- * but don't want to run the binary immediately.
+ * Download and install a package without executing it. This is useful for
+ * self-update or when you need the package files but don't want to run the
+ * binary immediately.
  *
  * @example
- * ```typescript
- * // Install @socketsecurity/cli without running it
- * const result = await downloadPackage({
- *   package: '@socketsecurity/cli@1.2.0',
- *   force: true
- * })
- * console.log('Installed to:', result.packageDir)
- * console.log('Binary at:', result.binaryPath)
- * ```
+ *   ;```typescript
+ *   // Install @socketsecurity/cli without running it
+ *   const result = await downloadPackage({
+ *     package: '@socketsecurity/cli@1.2.0',
+ *     force: true,
+ *   })
+ *   console.log('Installed to:', result.packageDir)
+ *   console.log('Binary at:', result.binaryPath)
+ *   ```
  */
 export declare function downloadPackage(options: DlxPackageOptions): Promise<DownloadPackageResult>;
 /**
- * Install package to ~/.socket/_dlx/<hash>/ if not already installed.
- * Uses pacote for installation (no npm CLI required).
- * Protected by process lock to prevent concurrent installation corruption.
+ * Install package to ~/.socket/_dlx/<hash>/ if not already installed. Uses
+ * pacote for installation (no npm CLI required). Protected by process lock to
+ * prevent concurrent installation corruption.
  *
  * @example
- * ```typescript
- * const { installed, packageDir } = await ensurePackageInstalled(
+ *   ```typescript
+ *   const { installed, packageDir } = await ensurePackageInstalled(
  *   'prettier',
  *   'prettier@3.0.0',
- *   false
- * )
- * console.log(`Installed: ${installed}, dir: ${packageDir}`)
- * ```
+ *   false,
+ *   )
+ *   console.log(`Installed: ${installed}, dir: ${packageDir}`)
+ *   ```
  */
 export declare function ensurePackageInstalled(packageName: string, packageSpec: string, force: boolean, install?: EnsurePackageInstallOptions | undefined): Promise<{
     installed: boolean;
     packageDir: string;
 }>;
 /**
- * Execute a package's binary with cross-platform shell handling.
- * The package must already be installed (use downloadPackage first).
+ * Execute a package's binary with cross-platform shell handling. The package
+ * must already be installed (use downloadPackage first).
  *
- * On Windows, script files (.bat, .cmd, .ps1) require shell: true.
- * Matches npm/npx execution behavior.
+ * On Windows, script files (.bat, .cmd, .ps1) require shell: true. Matches
+ * npm/npx execution behavior.
  *
  * @example
- * ```typescript
- * // Execute an already-installed package
- * const downloaded = await downloadPackage({ package: 'cowsay@1.5.0' })
- * const result = await executePackage(
- *   downloaded.binaryPath,
- *   ['Hello World'],
- *   { stdio: 'inherit' }
- * )
- * ```
+ *   ;```typescript
+ *   // Execute an already-installed package
+ *   const downloaded = await downloadPackage({ package: 'cowsay@1.5.0' })
+ *   const result = await executePackage(
+ *     downloaded.binaryPath,
+ *     ['Hello World'],
+ *     { stdio: 'inherit' },
+ *   )
+ *   ```
  */
 export declare function executePackage(binaryPath: string, args: readonly string[] | string[], spawnOptions?: SpawnOptions | undefined, spawnExtra?: SpawnExtra | undefined): ReturnType<typeof spawn>;
-/**
- * Find the binary path for an installed package.
- * Uses npm's bin resolution strategy with user-friendly fallbacks.
- * Resolves platform-specific wrappers (.cmd, .ps1, etc.) on Windows.
- *
- * Resolution strategy (cherry-picked from libnpmexec):
- * 1. Use npm's getBinFromManifest (handles aliases and standard cases)
- * 2. Fall back to user-provided binaryName if npm's strategy fails
- * 3. Try last segment of package name as final fallback
- * 4. Use first binary as last resort
- *
- * @example
- * ```typescript
- * const binPath = findBinaryPath(
- *   '/tmp/.socket/_dlx/a1b2c3d4',
- *   'prettier'
- * )
- * console.log(`Binary: ${binPath}`)
- * ```
- */
-export declare function findBinaryPath(packageDir: string, packageName: string, binaryName?: string): string;
-/**
- * Make all binaries in an installed package executable.
- * Reads the package.json bin field and makes all binaries executable (chmod 0o755).
- * Handles both single binary (string) and multiple binaries (object) formats.
- *
- * Aligns with npm's approach:
- * - Uses 0o755 permission (matches npm's cmd-shim)
- * - Reads bin field from package.json (matches npm's bin-links and libnpmexec)
- * - Handles both string and object bin formats
- *
- * References:
- * - npm cmd-shim: https://github.com/npm/cmd-shim/blob/main/lib/index.js
- * - npm getBinFromManifest: https://github.com/npm/libnpmexec/blob/main/lib/get-bin-from-manifest.js
- *
- * @example
- * ```typescript
- * makePackageBinsExecutable(
- *   '/tmp/.socket/_dlx/a1b2c3d4',
- *   'prettier'
- * )
- * ```
- */
-export declare function makePackageBinsExecutable(packageDir: string, packageName: string): void;
-/**
- * Build a PURL string for an npm package.
- * Follows the PURL spec for the npm type:
- *   - Scoped: `@scope/pkg` → `pkg:npm/%40scope/pkg@version`
- *   - Unscoped: `pkg` → `pkg:npm/pkg@version`
- *
- */
-export declare function npmPurl(name: string, version: string): string;
-/**
- * Parse package spec into name and version using npm-package-arg.
- * Examples:
- * - 'lodash@4.17.21' → { name: 'lodash', version: '4.17.21' }
- * - '@scope/pkg@1.0.0' → { name: '@scope/pkg', version: '1.0.0' }
- * - 'lodash' → { name: 'lodash', version: undefined }
- *
- * @example
- * ```typescript
- * parsePackageSpec('lodash@4.17.21')
- * // { name: 'lodash', version: '4.17.21' }
- *
- * parsePackageSpec('@scope/pkg')
- * // { name: '@scope/pkg', version: undefined }
- * ```
- */
-export declare function parsePackageSpec(spec: string): {
-    name: string;
-    version: string | undefined;
-};
-/**
- * Resolve binary path with cross-platform wrapper support.
- * On Windows, checks for .cmd, .bat, .ps1, .exe wrappers in order.
- * On Unix, uses path directly.
- *
- * Aligns with npm/npx binary resolution strategy.
- *
- * @example
- * ```typescript
- * const resolved = resolveBinaryPath('/tmp/.socket/_dlx/a1b2c3d4/prettier')
- * // On Windows: may resolve to '.cmd' or '.ps1' wrapper
- * // On Unix: returns the path unchanged
- * ```
- */
-export declare function resolveBinaryPath(basePath: string): string;
+export { binaryPathCacheSet } from './_internal';
+export { findBinaryPath, makePackageBinsExecutable, resolveBinaryPath, } from './binary-resolution';
+export { checkFirewallPurls, npmPurl } from './firewall';
+export { parsePackageSpec } from './spec';
+export type { DlxPackageOptions, DlxPackageResult, DownloadPackageResult, EnsurePackageInstallOptions, } from './types';