@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/paths/rewire.js

@@ -1,93 +1,129 @@
 "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 rewire_exports = {};
-__export(rewire_exports, {
-  clearPath: () => clearPath,
-  getPathValue: () => getPathValue,
-  hasOverride: () => hasOverride,
-  invalidateCaches: () => invalidateCaches,
-  registerCacheInvalidation: () => registerCacheInvalidation,
-  resetPaths: () => resetPaths,
-  setPath: () => setPath
-});
-module.exports = __toCommonJS(rewire_exports);
-var import_map_set = require("../primordials/map-set");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_map_set = require('../primordials/map-set.js');
+
+//#region src/paths/rewire.ts
+/**
+* @file Path rewiring utilities for testing. Allows tests to override
+*   os.tmpdir() and os.homedir() without directly modifying them. Features:
+*
+*   - Test-friendly setPath/clearPath/resetPaths that work in
+*     beforeEach/afterEach
+*   - Automatic cache invalidation for path-dependent modules
+*   - Thread-safe for concurrent test execution
+*/
 const stateSymbol = Symbol.for("@socketsecurity/lib/paths/rewire/state");
 const _globalThis = globalThis;
-if (!_globalThis[stateSymbol]) {
-  _globalThis[stateSymbol] = {
-    testOverrides: new import_map_set.MapCtor(),
-    valueCache: new import_map_set.MapCtor(),
-    cacheInvalidationCallbacks: []
-  };
-}
+if (!_globalThis[stateSymbol]) _globalThis[stateSymbol] = {
+	testOverrides: new require_primordials_map_set.MapCtor(),
+	valueCache: new require_primordials_map_set.MapCtor(),
+	cacheInvalidationCallbacks: []
+};
 const sharedState = _globalThis[stateSymbol];
 const testOverrides = sharedState.testOverrides;
 const valueCache = sharedState.valueCache;
 const cacheInvalidationCallbacks = sharedState.cacheInvalidationCallbacks;
+/**
+* Clear a specific path override.
+*/
 function clearPath(key) {
-  testOverrides.delete(key);
-  invalidateCaches();
+	testOverrides.delete(key);
+	invalidateCaches();
 }
+/**
+* Get a path value, checking overrides first.
+*
+* Resolution order: 1. Test overrides (set via setPath in beforeEach) 2. Cached
+* value (for performance) 3. Original function call (cached for subsequent
+* calls)
+*
+* @internal Used by path getters to support test rewiring
+*/
 function getPathValue(key, originalFn) {
-  if (testOverrides.has(key)) {
-    return testOverrides.get(key);
-  }
-  if (valueCache.has(key)) {
-    return valueCache.get(key);
-  }
-  const value = originalFn();
-  valueCache.set(key, value);
-  return value;
+	if (testOverrides.has(key)) return testOverrides.get(key);
+	if (valueCache.has(key)) return valueCache.get(key);
+	const value = originalFn();
+	valueCache.set(key, value);
+	return value;
 }
+/**
+* Check if a path has been overridden.
+*/
 function hasOverride(key) {
-  return testOverrides.has(key);
+	return testOverrides.has(key);
 }
+/**
+* Invalidate all cached paths. Called automatically when
+* setPath/clearPath/resetPaths are used. Can also be called manually for
+* advanced testing scenarios.
+*
+* @internal Primarily for internal use, but exported for advanced testing
+*/
 function invalidateCaches() {
-  valueCache.clear();
-  for (const callback of cacheInvalidationCallbacks) {
-    try {
-      callback();
-    } catch {
-    }
-  }
+	valueCache.clear();
+	for (const callback of cacheInvalidationCallbacks) try {
+		callback();
+	} catch {}
 }
+/**
+* Register a cache invalidation callback. Called by modules that need to clear
+* their caches when paths change.
+*
+* @internal Used by paths.ts and fs.ts
+*/
 function registerCacheInvalidation(callback) {
-  cacheInvalidationCallbacks.push(callback);
+	cacheInvalidationCallbacks.push(callback);
 }
+/**
+* Clear all path overrides and reset caches. Useful in afterEach hooks to
+* ensure clean test state.
+*
+* @example
+*   ;```typescript
+*   import { resetPaths } from '#paths/rewire'
+*
+*   afterEach(() => {
+*     resetPaths()
+*   })
+*   ```
+*/
 function resetPaths() {
-  testOverrides.clear();
-  invalidateCaches();
+	testOverrides.clear();
+	invalidateCaches();
 }
+/**
+* Set a path override for testing. This triggers cache invalidation for
+* path-dependent modules.
+*
+* @example
+*   ;```typescript
+*   import { setPath, resetPaths } from '#paths/rewire'
+*   import { getOsTmpDir } from './'
+*
+*   beforeEach(() => {
+*     setPath('tmpdir', '/custom/tmp')
+*   })
+*
+*   afterEach(() => {
+*     resetPaths()
+*   })
+*
+*   it('should use custom temp directory', () => {
+*     expect(getOsTmpDir()).toBe('/custom/tmp')
+*   })
+*   ```
+*/
 function setPath(key, value) {
-  testOverrides.set(key, value);
-  invalidateCaches();
+	testOverrides.set(key, value);
+	invalidateCaches();
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clearPath,
-  getPathValue,
-  hasOverride,
-  invalidateCaches,
-  registerCacheInvalidation,
-  resetPaths,
-  setPath
-});
+
+//#endregion
+exports.clearPath = clearPath;
+exports.getPathValue = getPathValue;
+exports.hasOverride = hasOverride;
+exports.invalidateCaches = invalidateCaches;
+exports.registerCacheInvalidation = registerCacheInvalidation;
+exports.resetPaths = resetPaths;
+exports.setPath = setPath;

package/dist/paths/socket.js

@@ -1,161 +1,281 @@
 "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 socket_exports = {};
-__export(socket_exports, {
-  getOsHomeDir: () => getOsHomeDir,
-  getOsTmpDir: () => getOsTmpDir,
-  getSocketAppCacheDir: () => getSocketAppCacheDir,
-  getSocketAppCacheTtlDir: () => getSocketAppCacheTtlDir,
-  getSocketAppDir: () => getSocketAppDir,
-  getSocketCacacheDir: () => getSocketCacacheDir,
-  getSocketCliDir: () => getSocketCliDir,
-  getSocketDlxDir: () => getSocketDlxDir,
-  getSocketHomePath: () => getSocketHomePath,
-  getSocketRegistryDir: () => getSocketRegistryDir,
-  getSocketRegistryGithubCacheDir: () => getSocketRegistryGithubCacheDir,
-  getSocketUserDir: () => getSocketUserDir,
-  getSocketWheelhouseDir: () => getSocketWheelhouseDir,
-  getUserHomeDir: () => getUserHomeDir
-});
-module.exports = __toCommonJS(socket_exports);
-var import_github = require("../constants/github");
-var import_socket = require("../constants/socket");
-var import_home = require("../env/home");
-var import_socket2 = require("../env/socket");
-var import_windows = require("../env/windows");
-var import_dirnames = require("./dirnames");
-var import_normalize = require("./normalize");
-var import_rewire = require("./rewire");
-var import_os = require("../node/os");
-var import_path = require("../node/path");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_node_os = require('../node/os.js');
+const require_paths_normalize = require('./normalize.js');
+const require_node_path = require('../node/path.js');
+const require_env_socket = require('../env/socket.js');
+const require_constants_github = require('../constants/github.js');
+const require_constants_socket = require('../constants/socket.js');
+const require_env_home = require('../env/home.js');
+const require_env_windows = require('../env/windows.js');
+const require_paths_dirnames = require('./dirnames.js');
+const require_paths_rewire = require('./rewire.js');
+
+//#region src/paths/socket.ts
+/**
+* @file Path utilities for Socket ecosystem directories. Provides
+*   platform-aware path resolution for Socket tools' shared directory
+*   structure. Directory Structure: ~/.socket/ ├── _cacache/ #
+*   Content-addressable cache for npm packages ├── _dlx/ # DLX installations
+*   (content-addressed by hash) │ ├── <hash>/ # npm package installs
+*   (dlx-package) │ └── <hash>/ # binary downloads (dlx-binary) ├── _socket/ #
+*   Socket CLI app directory ├── _registry/ # Socket Registry app directory └──
+*   _sfw/ # Socket Firewall app directory.
+*/
+/**
+* Get the OS home directory. Can be overridden in tests using
+* setPath('homedir', ...) from paths/rewire.
+*/
 function getOsHomeDir() {
-  return (0, import_rewire.getPathValue)("homedir", () => (0, import_os.getNodeOs)().homedir());
+	return require_paths_rewire.getPathValue("homedir", () => (/* @__PURE__ */ require_node_os.getNodeOs()).homedir());
 }
+/**
+* Get the OS temporary directory. Can be overridden in tests using
+* setPath('tmpdir', ...) from paths/rewire.
+*/
+/**
+* Get the OS temporary directory. Can be overridden in tests using
+* setPath('tmpdir', ...) from paths/rewire.
+*/
 function getOsTmpDir() {
-  return (0, import_rewire.getPathValue)("tmpdir", () => (0, import_os.getNodeOs)().tmpdir());
+	return require_paths_rewire.getPathValue("tmpdir", () => (/* @__PURE__ */ require_node_os.getNodeOs()).tmpdir());
 }
+/**
+* Get a Socket app cache directory (~/.socket/_<appName>/cache).
+*/
+/**
+* Get a Socket app cache directory (~/.socket/_<appName>/cache).
+*/
 function getSocketAppCacheDir(appName) {
-  return (0, import_normalize.normalizePath)((0, import_path.getNodePath)().join(getSocketAppDir(appName), import_dirnames.CACHE_DIR));
+	return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketAppDir(appName), require_paths_dirnames.CACHE_DIR));
 }
+/**
+* Get a Socket app TTL cache directory (~/.socket/_<appName>/cache/ttl).
+*/
+/**
+* Get a Socket app TTL cache directory (~/.socket/_<appName>/cache/ttl).
+*/
 function getSocketAppCacheTtlDir(appName) {
-  return (0, import_normalize.normalizePath)(
-    (0, import_path.getNodePath)().join(getSocketAppCacheDir(appName), import_dirnames.CACHE_TTL_DIR)
-  );
+	return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketAppCacheDir(appName), "ttl"));
 }
+/**
+* Get a Socket app directory (~/.socket/_<appName>).
+*/
+/**
+* Get a Socket app directory (~/.socket/_<appName>).
+*/
 function getSocketAppDir(appName) {
-  return (0, import_normalize.normalizePath)(
-    (0, import_path.getNodePath)().join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}${appName}`)
-  );
+	return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketUserDir(), `${"_"}${appName}`));
 }
+/**
+* Get the Socket cacache directory (~/.socket/_cacache). Can be overridden with
+* SOCKET_CACACHE_DIR environment variable or via setPath() for testing. Result
+* is cached via getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-cacache-dir', ...)
+* 2. SOCKET_CACACHE_DIR - Full override of cacache directory
+* 3. Default: $SOCKET_HOME/_cacache or $HOME/.socket/_cacache
+*/
+/**
+* Get the Socket cacache directory (~/.socket/_cacache). Can be overridden with
+* SOCKET_CACACHE_DIR environment variable or via setPath() for testing. Result
+* is cached via getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-cacache-dir', ...)
+* 2. SOCKET_CACACHE_DIR - Full override of cacache directory
+* 3. Default: $SOCKET_HOME/_cacache or $HOME/.socket/_cacache
+*/
 function getSocketCacacheDir() {
-  return (0, import_rewire.getPathValue)("socket-cacache-dir", () => {
-    if ((0, import_socket2.getSocketCacacheDirEnv)()) {
-      return (0, import_normalize.normalizePath)((0, import_socket2.getSocketCacacheDirEnv)());
-    }
-    return (0, import_normalize.normalizePath)(
-      (0, import_path.getNodePath)().join(getSocketUserDir(), `${import_socket.SOCKET_APP_PREFIX}cacache`)
-    );
-  });
+	return require_paths_rewire.getPathValue("socket-cacache-dir", () => {
+		if (/* @__PURE__ */ require_env_socket.getSocketCacacheDirEnv()) return /* @__PURE__ */ require_paths_normalize.normalizePath(/* @__PURE__ */ require_env_socket.getSocketCacacheDirEnv());
+		return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketUserDir(), `${"_"}cacache`));
+	});
 }
+/**
+* Get the Socket CLI directory (~/.socket/_socket).
+*/
+/**
+* Get the Socket CLI directory (~/.socket/_socket).
+*/
 function getSocketCliDir() {
-  return getSocketAppDir(import_socket.SOCKET_CLI_APP_NAME);
+	return getSocketAppDir(require_constants_socket.SOCKET_CLI_APP_NAME);
 }
+/**
+* Get the Socket DLX directory (~/.socket/_dlx). Can be overridden with
+* SOCKET_DLX_DIR environment variable or via setPath() for testing. Result is
+* cached via getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-dlx-dir', ...)
+* 2. SOCKET_DLX_DIR - Full override of DLX cache directory
+* 3. SOCKET_HOME/_dlx - Base directory override (inherits from getSocketUserDir)
+* 4. Default: $HOME/.socket/_dlx
+* 5. Fallback: /tmp/.socket/_dlx (Unix) or %TEMP%.socket_dlx (Windows)
+*/
+/**
+* Get the Socket DLX directory (~/.socket/_dlx). Can be overridden with
+* SOCKET_DLX_DIR environment variable or via setPath() for testing. Result is
+* cached via getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-dlx-dir', ...)
+* 2. SOCKET_DLX_DIR - Full override of DLX cache directory
+* 3. SOCKET_HOME/_dlx - Base directory override (inherits from getSocketUserDir)
+* 4. Default: $HOME/.socket/_dlx
+* 5. Fallback: /tmp/.socket/_dlx (Unix) or %TEMP%.socket_dlx (Windows)
+*/
 function getSocketDlxDir() {
-  return (0, import_rewire.getPathValue)("socket-dlx-dir", () => {
-    if ((0, import_socket2.getSocketDlxDirEnv)()) {
-      return (0, import_normalize.normalizePath)((0, import_socket2.getSocketDlxDirEnv)());
-    }
-    return (0, import_normalize.normalizePath)(
-      (0, import_path.getNodePath)().join(
-        getSocketUserDir(),
-        `${import_socket.SOCKET_APP_PREFIX}${import_socket.SOCKET_DLX_APP_NAME}`
-      )
-    );
-  });
+	return require_paths_rewire.getPathValue("socket-dlx-dir", () => {
+		if (/* @__PURE__ */ require_env_socket.getSocketDlxDirEnv()) return /* @__PURE__ */ require_paths_normalize.normalizePath(/* @__PURE__ */ require_env_socket.getSocketDlxDirEnv());
+		return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketUserDir(), `${"_"}${"dlx"}`));
+	});
 }
+/**
+* Get the Socket home directory (~/.socket). Alias for getSocketUserDir() for
+* consistency across Socket projects.
+*/
+/**
+* Get the Socket home directory (~/.socket). Alias for getSocketUserDir() for
+* consistency across Socket projects.
+*/
 function getSocketHomePath() {
-  return getSocketUserDir();
+	return getSocketUserDir();
 }
+/**
+* Get the Socket Registry directory (~/.socket/_registry).
+*/
+/**
+* Get the Socket Registry directory (~/.socket/_registry).
+*/
 function getSocketRegistryDir() {
-  return getSocketAppDir(import_socket.SOCKET_REGISTRY_APP_NAME);
+	return getSocketAppDir(require_constants_socket.SOCKET_REGISTRY_APP_NAME);
 }
+/**
+* Get the Socket Registry GitHub cache directory
+* (~/.socket/_registry/cache/ttl/github).
+*/
+/**
+* Get the Socket Registry GitHub cache directory
+* (~/.socket/_registry/cache/ttl/github).
+*/
 function getSocketRegistryGithubCacheDir() {
-  return (0, import_normalize.normalizePath)(
-    (0, import_path.getNodePath)().join(
-      getSocketAppCacheTtlDir(import_socket.SOCKET_REGISTRY_APP_NAME),
-      import_github.CACHE_GITHUB_DIR
-    )
-  );
+	return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketAppCacheTtlDir(require_constants_socket.SOCKET_REGISTRY_APP_NAME), require_constants_github.CACHE_GITHUB_DIR));
 }
+/**
+* Get the Socket Wheelhouse directory (~/.socket/_wheelhouse). Shared
+* cross-fleet location for binaries that every fleet member can reach without
+* each one re-downloading and re-extracting per-repo. Tool installers (janus,
+* sfw, etc.) drop their resolved executables under
+* `<wheelhouse>/<tool>/<version>/<platform-arch>/`; consumers add the
+* appropriate `bin/` to PATH or invoke the binary by absolute path.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-wheelhouse-dir', ...)
+* 2. SOCKET_HOME/_wheelhouse - Base directory override (inherits from
+*    getSocketUserDir)
+* 3. Default: $HOME/.socket/_wheelhouse
+*/
+/**
+* Get the Socket user directory (~/.socket). Can be overridden with SOCKET_HOME
+* environment variable or via setPath() for testing. Result is cached via
+* getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-user-dir', ...)
+* 2. SOCKET_HOME - Base directory override
+* 3. Default: $HOME/.socket
+* 4. Fallback: /tmp/.socket (Unix) or %TEMP%.socket (Windows)
+*/
 function getSocketUserDir() {
-  return (0, import_rewire.getPathValue)("socket-user-dir", () => {
-    const socketHome = (0, import_socket2.getSocketHome)();
-    if (socketHome) {
-      return (0, import_normalize.normalizePath)(socketHome);
-    }
-    return (0, import_normalize.normalizePath)((0, import_path.getNodePath)().join(getUserHomeDir(), import_dirnames.DOT_SOCKET_DIR));
-  });
+	return require_paths_rewire.getPathValue("socket-user-dir", () => {
+		const socketHome = /* @__PURE__ */ require_env_socket.getSocketHome();
+		if (socketHome) return /* @__PURE__ */ require_paths_normalize.normalizePath(socketHome);
+		return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getUserHomeDir(), require_paths_dirnames.DOT_SOCKET_DIR));
+	});
 }
+/**
+* Get the user's home directory. Uses environment variables directly to support
+* test mocking. Falls back to temporary directory if home is not available.
+*
+* Priority order: 1. HOME environment variable (Unix) 2. USERPROFILE
+* environment variable (Windows) 3. getNodeOs().homedir() 4. Fallback:
+* getNodeOs().tmpdir() (rarely used, for restricted environments)
+*/
+/**
+* Get the Socket Wheelhouse directory (~/.socket/_wheelhouse). Shared
+* cross-fleet location for binaries that every fleet member can reach without
+* each one re-downloading and re-extracting per-repo. Tool installers (janus,
+* sfw, etc.) drop their resolved executables under
+* `<wheelhouse>/<tool>/<version>/<platform-arch>/`; consumers add the
+* appropriate `bin/` to PATH or invoke the binary by absolute path.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-wheelhouse-dir', ...)
+* 2. SOCKET_HOME/_wheelhouse - Base directory override (inherits from
+*    getSocketUserDir)
+* 3. Default: $HOME/.socket/_wheelhouse
+*/
 function getSocketWheelhouseDir() {
-  return (0, import_rewire.getPathValue)("socket-wheelhouse-dir", () => {
-    return (0, import_normalize.normalizePath)(
-      (0, import_path.getNodePath)().join(
-        getSocketUserDir(),
-        `${import_socket.SOCKET_APP_PREFIX}${import_socket.SOCKET_WHEELHOUSE_APP_NAME}`
-      )
-    );
-  });
+	return require_paths_rewire.getPathValue("socket-wheelhouse-dir", () => {
+		return /* @__PURE__ */ require_paths_normalize.normalizePath((/* @__PURE__ */ require_node_path.getNodePath()).join(getSocketUserDir(), `${"_"}${require_constants_socket.SOCKET_WHEELHOUSE_APP_NAME}`));
+	});
 }
+/**
+* Get the Socket user directory (~/.socket). Can be overridden with SOCKET_HOME
+* environment variable or via setPath() for testing. Result is cached via
+* getPathValue for performance.
+*
+* Priority order:
+*
+* 1. Test override via setPath('socket-user-dir', ...)
+* 2. SOCKET_HOME - Base directory override
+* 3. Default: $HOME/.socket
+* 4. Fallback: /tmp/.socket (Unix) or %TEMP%.socket (Windows)
+*/
+/**
+* Get the user's home directory. Uses environment variables directly to support
+* test mocking. Falls back to temporary directory if home is not available.
+*
+* Priority order: 1. HOME environment variable (Unix) 2. USERPROFILE
+* environment variable (Windows) 3. getNodeOs().homedir() 4. Fallback:
+* getNodeOs().tmpdir() (rarely used, for restricted environments)
+*/
 function getUserHomeDir() {
-  const home = (0, import_home.getHome)();
-  if (home) {
-    return home;
-  }
-  const userProfile = (0, import_windows.getUserprofile)();
-  if (userProfile) {
-    return userProfile;
-  }
-  try {
-    const osHome = getOsHomeDir();
-    if (osHome) {
-      return osHome;
-    }
-  } catch {
-  }
-  return getOsTmpDir();
+	const home = /* @__PURE__ */ require_env_home.getHome();
+	if (home) return home;
+	const userProfile = /* @__PURE__ */ require_env_windows.getUserprofile();
+	if (userProfile) return userProfile;
+	try {
+		const osHome = getOsHomeDir();
+		if (osHome) return osHome;
+	} catch {}
+	/* c8 ignore next 2 - Triple-fallback only fires when HOME +
+	USERPROFILE + os.homedir() all fail; not reachable in tests. */
+	return getOsTmpDir();
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getOsHomeDir,
-  getOsTmpDir,
-  getSocketAppCacheDir,
-  getSocketAppCacheTtlDir,
-  getSocketAppDir,
-  getSocketCacacheDir,
-  getSocketCliDir,
-  getSocketDlxDir,
-  getSocketHomePath,
-  getSocketRegistryDir,
-  getSocketRegistryGithubCacheDir,
-  getSocketUserDir,
-  getSocketWheelhouseDir,
-  getUserHomeDir
-});
+
+//#endregion
+exports.getOsHomeDir = getOsHomeDir;
+exports.getOsTmpDir = getOsTmpDir;
+exports.getSocketAppCacheDir = getSocketAppCacheDir;
+exports.getSocketAppCacheTtlDir = getSocketAppCacheTtlDir;
+exports.getSocketAppDir = getSocketAppDir;
+exports.getSocketCacacheDir = getSocketCacacheDir;
+exports.getSocketCliDir = getSocketCliDir;
+exports.getSocketDlxDir = getSocketDlxDir;
+exports.getSocketHomePath = getSocketHomePath;
+exports.getSocketRegistryDir = getSocketRegistryDir;
+exports.getSocketRegistryGithubCacheDir = getSocketRegistryGithubCacheDir;
+exports.getSocketUserDir = getSocketUserDir;
+exports.getSocketWheelhouseDir = getSocketWheelhouseDir;
+exports.getUserHomeDir = getUserHomeDir;

package/dist/paths/walk.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file Walk parent directories. `walkUp` is the lazy ancestor generator that
+ *   `fs/find-up` and package-root lookups build on: given a starting path it
+ *   yields that path, then each parent, up to and INCLUDING the filesystem root
+ *   (or a caller-supplied `stopAt` boundary). Lazy so a caller can stop early
+ *   without computing the whole chain.
+ */
+export interface WalkUpOptions {
+    /**
+     * Starting directory. Relative `from` values are resolved against this.
+     * Defaults to `process.cwd()`.
+     */
+    cwd?: string | undefined;
+    /**
+     * Last directory to yield (INCLUSIVE). Traversal stops after this path is
+     * emitted. Defaults to the filesystem root.
+     */
+    stopAt?: string | undefined;
+}
+/**
+ * Lazily yield `from` and each of its ancestor directories, up to and including
+ * the filesystem root (or `stopAt`). Each yielded path is normalized to forward
+ * slashes.
+ *
+ * @example
+ *   ;```ts
+ *   for (const dir of walkUp('/a/b/c')) {
+ *     // '/a/b/c', '/a/b', '/a', '/'
+ *   }
+ *
+ *   // Stop at a boundary (inclusive):
+ *   [...walkUp('/a/b/c', { stopAt: '/a' })] // ['/a/b/c', '/a/b', '/a']
+ *   ```
+ *
+ * @param from - Path to start from. Relative values resolve against `cwd`.
+ * @param options - `cwd` and `stopAt` boundary.
+ *
+ * @returns Generator of normalized absolute directory paths.
+ */
+export declare function walkUp(from: string, options?: WalkUpOptions | undefined): Generator<string>;