@socketsecurity/lib 5.2.1 → 5.4.0

package/dist/dlx/binary.js

@@ -1,10 +1,8 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
-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)
@@ -18,14 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 binary_exports = {};
 __export(binary_exports, {
@@ -37,9 +27,6 @@ __export(binary_exports, {
   listDlxCache: () => listDlxCache
 });
 module.exports = __toCommonJS(binary_exports);
-var import_crypto = require("crypto");
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
 var import_platform = require("../constants/platform");
 var import_time = require("../constants/time");
 var import_cache = require("./cache");
@@ -51,16 +38,32 @@ var import_normalize = require("../paths/normalize");
 var import_socket = require("../paths/socket");
 var import_process_lock = require("../process-lock");
 var import_spawn = require("../spawn");
+let _crypto;
+// @__NO_SIDE_EFFECTS__
+function getCrypto() {
+  if (_crypto === void 0) {
+    _crypto = require("crypto");
+  }
+  return _crypto;
+}
 let _fs;
 // @__NO_SIDE_EFFECTS__
 function getFs() {
   if (_fs === void 0) {
-    _fs = require("node:fs");
+    _fs = require("fs");
   }
   return _fs;
 }
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 function getMetadataPath(cacheEntryPath) {
-  return import_path.default.join(cacheEntryPath, ".dlx-metadata.json");
+  return (/* @__PURE__ */ getPath()).join(cacheEntryPath, ".dlx-metadata.json");
 }
 async function isCacheValid(cacheEntryPath, cacheTtl) {
   const fs = /* @__PURE__ */ getFs();
@@ -85,17 +88,19 @@ async function isCacheValid(cacheEntryPath, cacheTtl) {
   }
 }
 async function downloadBinaryFile(url, destPath, checksum) {
-  const cacheEntryDir = import_path.default.dirname(destPath);
-  const lockPath = import_path.default.join(cacheEntryDir, "concurrency.lock");
+  const crypto = /* @__PURE__ */ getCrypto();
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
+  const cacheEntryDir = path.dirname(destPath);
+  const lockPath = path.join(cacheEntryDir, "concurrency.lock");
   return await import_process_lock.processLock.withLock(
     lockPath,
     async () => {
-      const fs = /* @__PURE__ */ getFs();
       if (fs.existsSync(destPath)) {
         const stats = await fs.promises.stat(destPath);
         if (stats.size > 0) {
           const fileBuffer2 = await fs.promises.readFile(destPath);
-          const hasher2 = (0, import_crypto.createHash)("sha256");
+          const hasher2 = crypto.createHash("sha256");
           hasher2.update(fileBuffer2);
           return hasher2.digest("hex");
         }
@@ -111,7 +116,7 @@ Check your internet connection or verify the URL is accessible.`,
         );
       }
       const fileBuffer = await fs.promises.readFile(destPath);
-      const hasher = (0, import_crypto.createHash)("sha256");
+      const hasher = crypto.createHash("sha256");
       hasher.update(fileBuffer);
       const actualChecksum = hasher.digest("hex");
       if (checksum && actualChecksum !== checksum) {
@@ -140,8 +145,8 @@ async function writeMetadata(cacheEntryPath, cacheKey, url, binaryName, checksum
     timestamp: Date.now(),
     checksum,
     checksum_algorithm: "sha256",
-    platform: import_os.default.platform(),
-    arch: import_os.default.arch(),
+    platform: (0, import_platform.getPlatform)(),
+    arch: (0, import_platform.getArch)(),
     size,
     source: {
       type: "download",
@@ -154,9 +159,9 @@ async function writeMetadata(cacheEntryPath, cacheKey, url, binaryName, checksum
     const spec = `${url}:${binaryName}`;
     await import_manifest.dlxManifest.setBinaryEntry(spec, cacheKey, {
       checksum,
-      checksum_algorithm: "sha256",
-      platform: import_os.default.platform(),
-      arch: import_os.default.arch(),
+      checksum_algorithm: metadata.checksum_algorithm,
+      platform: metadata.platform,
+      arch: metadata.arch,
       size,
       source: {
         type: "download",
@@ -174,9 +179,10 @@ async function cleanDlxCache(maxAge = import_time.DLX_BINARY_CACHE_TTL) {
   }
   let cleaned = 0;
   const now = Date.now();
+  const path = /* @__PURE__ */ getPath();
   const entries = await fs.promises.readdir(cacheDir);
   for (const entry of entries) {
-    const entryPath = import_path.default.join(cacheDir, entry);
+    const entryPath = path.join(cacheDir, entry);
     const metaPath = getMetadataPath(entryPath);
     try {
       if (!await (0, import_fs.isDir)(entryPath)) {
@@ -215,14 +221,15 @@ async function dlxBinary(args, options, spawnExtra) {
     url,
     yes
   } = { __proto__: null, ...options };
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const force = yes === true ? true : userForce;
   const cacheDir = getDlxCachePath();
-  const binaryName = name || `binary-${process.platform}-${import_os.default.arch()}`;
+  const binaryName = name || `binary-${process.platform}-${(0, import_platform.getArch)()}`;
   const spec = `${url}:${binaryName}`;
   const cacheKey = (0, import_cache.generateCacheKey)(spec);
-  const cacheEntryDir = import_path.default.join(cacheDir, cacheKey);
-  const binaryPath = (0, import_normalize.normalizePath)(import_path.default.join(cacheEntryDir, binaryName));
-  const fs = /* @__PURE__ */ getFs();
+  const cacheEntryDir = path.join(cacheDir, cacheKey);
+  const binaryPath = (0, import_normalize.normalizePath)(path.join(cacheEntryDir, binaryName));
   let downloaded = false;
   let computedChecksum = checksum;
   if (!force && fs.existsSync(cacheEntryDir) && await isCacheValid(cacheEntryDir, cacheTtl)) {
@@ -280,7 +287,7 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
     ...spawnOptions,
     env: {
       ...spawnOptions?.env,
-      PATH: `${cacheEntryDir}${import_path.default.delimiter}${process.env["PATH"] || ""}`
+      PATH: `${cacheEntryDir}${(/* @__PURE__ */ getPath()).delimiter}${process.env["PATH"] || ""}`
     },
     shell: true
   } : spawnOptions;
@@ -299,13 +306,14 @@ async function downloadBinary(options) {
     name,
     url
   } = { __proto__: null, ...options };
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const cacheDir = getDlxCachePath();
-  const binaryName = name || `binary-${process.platform}-${import_os.default.arch()}`;
+  const binaryName = name || `binary-${process.platform}-${(0, import_platform.getArch)()}`;
   const spec = `${url}:${binaryName}`;
   const cacheKey = (0, import_cache.generateCacheKey)(spec);
-  const cacheEntryDir = import_path.default.join(cacheDir, cacheKey);
-  const binaryPath = (0, import_normalize.normalizePath)(import_path.default.join(cacheEntryDir, binaryName));
-  const fs = /* @__PURE__ */ getFs();
+  const cacheEntryDir = path.join(cacheDir, cacheKey);
+  const binaryPath = (0, import_normalize.normalizePath)(path.join(cacheEntryDir, binaryName));
   let downloaded = false;
   if (!force && fs.existsSync(cacheEntryDir) && await isCacheValid(cacheEntryDir, cacheTtl)) {
     downloaded = false;
@@ -352,12 +360,13 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
 }
 function executeBinary(binaryPath, args, spawnOptions, spawnExtra) {
   const needsShell = import_platform.WIN32 && /\.(?:bat|cmd|ps1)$/i.test(binaryPath);
-  const cacheEntryDir = import_path.default.dirname(binaryPath);
+  const path = /* @__PURE__ */ getPath();
+  const cacheEntryDir = path.dirname(binaryPath);
   const finalSpawnOptions = needsShell ? {
     ...spawnOptions,
     env: {
       ...spawnOptions?.env,
-      PATH: `${cacheEntryDir}${import_path.default.delimiter}${process.env["PATH"] || ""}`
+      PATH: `${cacheEntryDir}${path.delimiter}${process.env["PATH"] || ""}`
     },
     shell: true
   } : spawnOptions;
@@ -374,9 +383,10 @@ async function listDlxCache() {
   }
   const results = [];
   const now = Date.now();
+  const path = /* @__PURE__ */ getPath();
   const entries = await fs.promises.readdir(cacheDir);
   for (const entry of entries) {
-    const entryPath = import_path.default.join(cacheDir, entry);
+    const entryPath = path.join(cacheDir, entry);
     try {
       if (!await (0, import_fs.isDir)(entryPath)) {
         continue;
@@ -392,7 +402,7 @@ async function listDlxCache() {
       const files = await fs.promises.readdir(entryPath);
       const binaryFile = files.find((f) => !f.startsWith("."));
       if (binaryFile) {
-        const binaryPath = import_path.default.join(entryPath, binaryFile);
+        const binaryPath = path.join(entryPath, binaryFile);
         const binaryStats = await fs.promises.stat(binaryPath);
         results.push({
           age: now - (metaObj["timestamp"] || 0),

package/dist/dlx/cache.js

@@ -22,9 +22,17 @@ __export(cache_exports, {
   generateCacheKey: () => generateCacheKey
 });
 module.exports = __toCommonJS(cache_exports);
-var import_node_crypto = require("node:crypto");
+let _crypto;
+// @__NO_SIDE_EFFECTS__
+function getCrypto() {
+  if (_crypto === void 0) {
+    _crypto = require("crypto");
+  }
+  return _crypto;
+}
 function generateCacheKey(spec) {
-  return (0, import_node_crypto.createHash)("sha512").update(spec).digest("hex").substring(0, 16);
+  const crypto = /* @__PURE__ */ getCrypto();
+  return crypto.createHash("sha512").update(spec).digest("hex").substring(0, 16);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/dlx/dir.js

@@ -35,7 +35,7 @@ let _fs;
 // @__NO_SIDE_EFFECTS__
 function getFs() {
   if (_fs === void 0) {
-    _fs = require("node:fs");
+    _fs = require("fs");
   }
   return _fs;
 }

package/dist/dlx/manifest.d.ts

@@ -15,7 +15,7 @@ export interface PackageDetails {
  */
 export interface BinaryDetails {
     checksum: string;
-    checksum_algorithm: 'sha256' | 'sha512';
+    checksum_algorithm: ChecksumAlgorithm;
     platform: string;
     arch: string;
     size: number;
@@ -24,6 +24,7 @@ export interface BinaryDetails {
         url: string;
     };
 }
+export type ChecksumAlgorithm = 'sha256' | 'sha512';
 /**
  * Unified manifest entry for all cached items (packages and binaries).
  * Shared fields at root, type-specific fields in details.

package/dist/dlx/manifest.js

@@ -1,10 +1,8 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
-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)
@@ -18,14 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 manifest_exports = {};
 __export(manifest_exports, {
@@ -35,12 +25,26 @@ __export(manifest_exports, {
   isPackageEntry: () => isPackageEntry
 });
 module.exports = __toCommonJS(manifest_exports);
-var import_fs = require("fs");
-var import_path = __toESM(require("path"));
-var import_fs2 = require("../fs");
+var import_fs = require("../fs");
 var import_logger = require("../logger");
 var import_socket = require("../paths/socket");
 var import_process_lock = require("../process-lock");
+let _fs;
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 const logger = (0, import_logger.getDefaultLogger)();
 const MANIFEST_FILE_NAME = ".dlx-manifest.json";
 function isPackageEntry(entry) {
@@ -53,7 +57,7 @@ class DlxManifest {
   manifestPath;
   lockPath;
   constructor(options = {}) {
-    this.manifestPath = options.manifestPath ?? import_path.default.join((0, import_socket.getSocketDlxDir)(), MANIFEST_FILE_NAME);
+    this.manifestPath = options.manifestPath ?? (/* @__PURE__ */ getPath()).join((0, import_socket.getSocketDlxDir)(), MANIFEST_FILE_NAME);
     this.lockPath = `${this.manifestPath}.lock`;
   }
   /**
@@ -61,10 +65,10 @@ class DlxManifest {
    */
   readManifest() {
     try {
-      if (!(0, import_fs.existsSync)(this.manifestPath)) {
+      if (!(/* @__PURE__ */ getFs()).existsSync(this.manifestPath)) {
         return /* @__PURE__ */ Object.create(null);
       }
-      const rawContent = (0, import_fs2.readFileUtf8Sync)(this.manifestPath);
+      const rawContent = (0, import_fs.readFileUtf8Sync)(this.manifestPath);
       const content = (typeof rawContent === "string" ? rawContent : rawContent.toString("utf8")).trim();
       if (!content) {
         return /* @__PURE__ */ Object.create(null);
@@ -134,9 +138,9 @@ class DlxManifest {
    * Write the manifest file atomically.
    */
   async writeManifest(data) {
-    const manifestDir = import_path.default.dirname(this.manifestPath);
+    const manifestDir = (/* @__PURE__ */ getPath()).dirname(this.manifestPath);
     try {
-      (0, import_fs2.safeMkdirSync)(manifestDir, { recursive: true });
+      (0, import_fs.safeMkdirSync)(manifestDir, { recursive: true });
     } catch (error) {
       logger.warn(
         `Failed to create manifest directory: ${error instanceof Error ? error.message : String(error)}`
@@ -145,18 +149,18 @@ class DlxManifest {
     const content = JSON.stringify(data, null, 2);
     const tempPath = `${this.manifestPath}.tmp`;
     try {
-      (0, import_fs.writeFileSync)(tempPath, content, "utf8");
-      (0, import_fs.writeFileSync)(this.manifestPath, content, "utf8");
+      (/* @__PURE__ */ getFs()).writeFileSync(tempPath, content, "utf8");
+      (/* @__PURE__ */ getFs()).writeFileSync(this.manifestPath, content, "utf8");
       try {
-        if ((0, import_fs.existsSync)(tempPath)) {
-          (0, import_fs.unlinkSync)(tempPath);
+        if ((/* @__PURE__ */ getFs()).existsSync(tempPath)) {
+          (/* @__PURE__ */ getFs()).unlinkSync(tempPath);
         }
       } catch {
       }
     } catch (error) {
       try {
-        if ((0, import_fs.existsSync)(tempPath)) {
-          (0, import_fs.unlinkSync)(tempPath);
+        if ((/* @__PURE__ */ getFs()).existsSync(tempPath)) {
+          (/* @__PURE__ */ getFs()).unlinkSync(tempPath);
         }
       } catch {
       }
@@ -171,8 +175,8 @@ class DlxManifest {
     await import_process_lock.processLock.withLock(this.lockPath, async () => {
       let data = /* @__PURE__ */ Object.create(null);
       try {
-        if ((0, import_fs.existsSync)(this.manifestPath)) {
-          const content2 = (0, import_fs.readFileSync)(this.manifestPath, "utf8");
+        if ((/* @__PURE__ */ getFs()).existsSync(this.manifestPath)) {
+          const content2 = (/* @__PURE__ */ getFs()).readFileSync(this.manifestPath, "utf8");
           if (content2.trim()) {
             data = JSON.parse(content2);
           }
@@ -183,9 +187,9 @@ class DlxManifest {
         );
       }
       data[name] = record;
-      const manifestDir = import_path.default.dirname(this.manifestPath);
+      const manifestDir = (/* @__PURE__ */ getPath()).dirname(this.manifestPath);
       try {
-        (0, import_fs2.safeMkdirSync)(manifestDir, { recursive: true });
+        (0, import_fs.safeMkdirSync)(manifestDir, { recursive: true });
       } catch (error) {
         logger.warn(
           `Failed to create manifest directory: ${error instanceof Error ? error.message : String(error)}`
@@ -194,18 +198,18 @@ class DlxManifest {
       const content = JSON.stringify(data, null, 2);
       const tempPath = `${this.manifestPath}.tmp`;
       try {
-        (0, import_fs.writeFileSync)(tempPath, content, "utf8");
-        (0, import_fs.writeFileSync)(this.manifestPath, content, "utf8");
+        (/* @__PURE__ */ getFs()).writeFileSync(tempPath, content, "utf8");
+        (/* @__PURE__ */ getFs()).writeFileSync(this.manifestPath, content, "utf8");
         try {
-          if ((0, import_fs.existsSync)(tempPath)) {
-            (0, import_fs.unlinkSync)(tempPath);
+          if ((/* @__PURE__ */ getFs()).existsSync(tempPath)) {
+            (/* @__PURE__ */ getFs()).unlinkSync(tempPath);
           }
         } catch {
         }
       } catch (error) {
         try {
-          if ((0, import_fs.existsSync)(tempPath)) {
-            (0, import_fs.unlinkSync)(tempPath);
+          if ((/* @__PURE__ */ getFs()).existsSync(tempPath)) {
+            (/* @__PURE__ */ getFs()).unlinkSync(tempPath);
           }
         } catch {
         }
@@ -219,17 +223,17 @@ class DlxManifest {
   async clear(name) {
     await import_process_lock.processLock.withLock(this.lockPath, async () => {
       try {
-        if (!(0, import_fs.existsSync)(this.manifestPath)) {
+        if (!(/* @__PURE__ */ getFs()).existsSync(this.manifestPath)) {
           return;
         }
-        const content = (0, import_fs.readFileSync)(this.manifestPath, "utf8");
+        const content = (/* @__PURE__ */ getFs()).readFileSync(this.manifestPath, "utf8");
         if (!content.trim()) {
           return;
         }
         const data = JSON.parse(content);
         delete data[name];
         const updatedContent = JSON.stringify(data, null, 2);
-        (0, import_fs.writeFileSync)(this.manifestPath, updatedContent, "utf8");
+        (/* @__PURE__ */ getFs()).writeFileSync(this.manifestPath, updatedContent, "utf8");
       } catch (error) {
         logger.warn(
           `Failed to clear cache for ${name}: ${error instanceof Error ? error.message : String(error)}`
@@ -243,8 +247,8 @@ class DlxManifest {
   async clearAll() {
     await import_process_lock.processLock.withLock(this.lockPath, async () => {
       try {
-        if ((0, import_fs.existsSync)(this.manifestPath)) {
-          (0, import_fs.unlinkSync)(this.manifestPath);
+        if ((/* @__PURE__ */ getFs()).existsSync(this.manifestPath)) {
+          (/* @__PURE__ */ getFs()).unlinkSync(this.manifestPath);
         }
       } catch (error) {
         logger.warn(
@@ -268,10 +272,10 @@ class DlxManifest {
    */
   getAllPackages() {
     try {
-      if (!(0, import_fs.existsSync)(this.manifestPath)) {
+      if (!(/* @__PURE__ */ getFs()).existsSync(this.manifestPath)) {
         return [];
       }
-      const rawContent = (0, import_fs2.readFileUtf8Sync)(this.manifestPath);
+      const rawContent = (0, import_fs.readFileUtf8Sync)(this.manifestPath);
       const content = (typeof rawContent === "string" ? rawContent : rawContent.toString("utf8")).trim();
       if (!content) {
         return [];

package/dist/dlx/package.js

@@ -34,8 +34,6 @@ __export(package_exports, {
   executePackage: () => executePackage
 });
 module.exports = __toCommonJS(package_exports);
-var import_node_fs = __toESM(require("node:fs"));
-var import_path = __toESM(require("path"));
 var import_platform = require("../constants/platform");
 var import_packages = require("../constants/packages");
 var import_cache = require("./cache");
@@ -48,6 +46,22 @@ var import_normalize = require("../paths/normalize");
 var import_socket = require("../paths/socket");
 var import_process_lock = require("../process-lock");
 var import_spawn = require("../spawn");
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("fs");
+  }
+  return _fs;
+}
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("path");
+  }
+  return _path;
+}
 const rangeOperatorsRegExp = /[~^><=xX* ]|\|\|/;
 function parsePackageSpec(spec) {
   try {
@@ -69,10 +83,12 @@ function parsePackageSpec(spec) {
   }
 }
 async function ensurePackageInstalled(packageName, packageSpec, force) {
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const cacheKey = (0, import_cache.generateCacheKey)(packageSpec);
-  const packageDir = (0, import_normalize.normalizePath)(import_path.default.join((0, import_socket.getSocketDlxDir)(), cacheKey));
+  const packageDir = (0, import_normalize.normalizePath)(path.join((0, import_socket.getSocketDlxDir)(), cacheKey));
   const installedDir = (0, import_normalize.normalizePath)(
-    import_path.default.join(packageDir, "node_modules", packageName)
+    path.join(packageDir, "node_modules", packageName)
   );
   try {
     await (0, import_fs.safeMkdir)(packageDir);
@@ -96,13 +112,13 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
       cause: e
     });
   }
-  const lockPath = import_path.default.join(packageDir, "concurrency.lock");
+  const lockPath = path.join(packageDir, "concurrency.lock");
   return await import_process_lock.processLock.withLock(
     lockPath,
     async () => {
-      if (!force && import_node_fs.default.existsSync(installedDir)) {
-        const pkgJsonPath = import_path.default.join(installedDir, "package.json");
-        if (import_node_fs.default.existsSync(pkgJsonPath)) {
+      if (!force && fs.existsSync(installedDir)) {
+        const pkgJsonPath = path.join(installedDir, "package.json");
+        if (fs.existsSync(pkgJsonPath)) {
           return { installed: false, packageDir };
         }
       }
@@ -110,11 +126,11 @@ Ensure the filesystem is writable or set SOCKET_DLX_DIR to a writable location.`
       try {
         await import_pacote.default.extract(packageSpec, installedDir, {
           // Use consistent pacote cache path (respects npm cache locations when available).
-          cache: pacoteCachePath || import_path.default.join(packageDir, ".cache")
+          cache: pacoteCachePath || path.join(packageDir, ".cache")
         });
         const arb = new import_arborist.default({
           path: installedDir,
-          cache: pacoteCachePath || import_path.default.join(packageDir, ".cache"),
+          cache: pacoteCachePath || path.join(packageDir, ".cache"),
           // Skip devDependencies (production-only like npx).
           omit: ["dev"],
           // Security: Skip install/preinstall/postinstall scripts to prevent arbitrary code execution.
@@ -167,20 +183,22 @@ function resolveBinaryPath(basePath) {
   if (!import_platform.WIN32) {
     return basePath;
   }
+  const fs = /* @__PURE__ */ getFs();
   const extensions = [".cmd", ".bat", ".ps1", ".exe", ""];
   for (const ext of extensions) {
     const testPath = basePath + ext;
-    if (import_node_fs.default.existsSync(testPath)) {
+    if (fs.existsSync(testPath)) {
       return testPath;
     }
   }
   return basePath;
 }
 function findBinaryPath(packageDir, packageName, binaryName) {
+  const path = /* @__PURE__ */ getPath();
   const installedDir = (0, import_normalize.normalizePath)(
-    import_path.default.join(packageDir, "node_modules", packageName)
+    path.join(packageDir, "node_modules", packageName)
   );
-  const pkgJsonPath = import_path.default.join(installedDir, "package.json");
+  const pkgJsonPath = path.join(installedDir, "package.json");
   const pkgJson = (0, import_fs.readJsonSync)(pkgJsonPath);
   const bin = pkgJson["bin"];
   let binName;
@@ -226,7 +244,7 @@ function findBinaryPath(packageDir, packageName, binaryName) {
   if (!binPath) {
     throw new Error(`No binary found for package "${packageName}"`);
   }
-  const rawPath = (0, import_normalize.normalizePath)(import_path.default.join(installedDir, binPath));
+  const rawPath = (0, import_normalize.normalizePath)(path.join(installedDir, binPath));
   return resolveBinaryPath(rawPath);
 }
 async function dlxPackage(args, options, spawnExtra) {
@@ -246,10 +264,12 @@ function makePackageBinsExecutable(packageDir, packageName) {
   if (import_platform.WIN32) {
     return;
   }
+  const fs = /* @__PURE__ */ getFs();
+  const path = /* @__PURE__ */ getPath();
   const installedDir = (0, import_normalize.normalizePath)(
-    import_path.default.join(packageDir, "node_modules", packageName)
+    path.join(packageDir, "node_modules", packageName)
   );
-  const pkgJsonPath = import_path.default.join(installedDir, "package.json");
+  const pkgJsonPath = path.join(installedDir, "package.json");
   try {
     const pkgJson = (0, import_fs.readJsonSync)(pkgJsonPath);
     const bin = pkgJson["bin"];
@@ -264,10 +284,10 @@ function makePackageBinsExecutable(packageDir, packageName) {
       binPaths.push(...Object.values(binObj));
     }
     for (const binPath of binPaths) {
-      const fullPath = (0, import_normalize.normalizePath)(import_path.default.join(installedDir, binPath));
-      if (import_node_fs.default.existsSync(fullPath)) {
+      const fullPath = (0, import_normalize.normalizePath)(path.join(installedDir, binPath));
+      if (fs.existsSync(fullPath)) {
         try {
-          import_node_fs.default.chmodSync(fullPath, 493);
+          fs.chmodSync(fullPath, 493);
         } catch {
         }
       }

package/dist/dlx/packages.js

@@ -34,7 +34,7 @@ let _fs;
 // @__NO_SIDE_EFFECTS__
 function getFs() {
   if (_fs === void 0) {
-    _fs = require("node:fs");
+    _fs = require("fs");
   }
   return _fs;
 }

package/dist/dlx/paths.js

@@ -32,7 +32,7 @@ let _path;
 // @__NO_SIDE_EFFECTS__
 function getPath() {
   if (_path === void 0) {
-    _path = require("node:path");
+    _path = require("path");
   }
   return _path;
 }

package/dist/env/rewire.js

@@ -28,9 +28,17 @@ __export(rewire_exports, {
   withEnvSync: () => withEnvSync
 });
 module.exports = __toCommonJS(rewire_exports);
-var import_async_hooks = require("async_hooks");
 var import_helpers = require("./helpers");
-const isolatedOverridesStorage = new import_async_hooks.AsyncLocalStorage();
+let _async_hooks;
+// @__NO_SIDE_EFFECTS__
+function getAsyncHooks() {
+  if (_async_hooks === void 0) {
+    _async_hooks = require("async_hooks");
+  }
+  return _async_hooks;
+}
+const { AsyncLocalStorage } = /* @__PURE__ */ getAsyncHooks();
+const isolatedOverridesStorage = new AsyncLocalStorage();
 const sharedOverridesSymbol = Symbol.for(
   "@socketsecurity/lib/env/rewire/test-overrides"
 );