@photostructure/fs-metadata 0.3.2 → 0.3.3

package/dist/index.mjs

@@ -1,31 +1,19 @@
-// src/index.mts
-import { dirname as dirname3 } from "node:path";
-import { fileURLToPath } from "node:url";
+// node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
 
-// src/setup.ts
+// src/index.ts
 import NodeGypBuild from "node-gyp-build";
 
 // src/debuglog.ts
 import { debuglog, format } from "node:util";
-
-// src/defer.ts
 function defer(thunk) {
-  let computed = false;
-  let value;
-  const fn = () => {
-    if (!computed) {
-      computed = true;
-      value = thunk();
-    }
-    return value;
-  };
-  fn.reset = () => {
-    computed = false;
-  };
-  return fn;
+  let t;
+  return () => t ??= thunk();
 }
-
-// src/debuglog.ts
 var debugLogContext = defer(() => {
   for (const ea of ["fs-metadata", "fs-meta"]) {
     if (debuglog(ea).enabled) {
@@ -47,31 +35,32 @@ function debug(msg, ...args) {
   process.stderr.write(timestamp + format(msg, ...args) + "\n");
 }
 
-// src/fs.ts
-import { opendir, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+// src/defer.ts
+function defer2(thunk) {
+  let computed = false;
+  let value;
+  const fn = () => {
+    if (!computed) {
+      computed = true;
+      value = thunk();
+    }
+    return value;
+  };
+  fn.reset = () => {
+    computed = false;
+  };
+  return fn;
+}
 
-// src/async.ts
-import { availableParallelism } from "node:os";
-import { env } from "node:process";
+// src/stack_path.ts
+import { dirname } from "node:path";
 
-// src/number.ts
-function isNumber(value) {
-  return typeof value === "number" && isFinite(value);
-}
-var INTEGER_REGEX = /^-?\d+$/;
-function toInt(value) {
-  try {
-    if (value == null) return;
-    const s = String(value).trim();
-    return INTEGER_REGEX.test(s) ? parseInt(s) : void 0;
-  } catch {
-    return;
-  }
-}
-function gt0(value) {
-  return isNumber(value) && value > 0;
-}
+// src/platform.ts
+import { arch, platform } from "node:process";
+var isLinux = platform === "linux";
+var isWindows = platform === "win32";
+var isMacOS = platform === "darwin";
+var isArm = isLinux && arch.startsWith("arm");
 
 // src/string.ts
 function isString(input) {
@@ -105,6 +94,103 @@ function sortObjectsByLocale(arr, fn, locales, options) {
   return arr.sort((a, b) => fn(a).localeCompare(fn(b), locales, options));
 }
 
+// src/stack_path.ts
+function getCallerDirname() {
+  const e = new Error();
+  if (e.stack == null) {
+    Error.captureStackTrace(e);
+  }
+  return dirname(extractCallerPath(e.stack));
+}
+var patterns = isWindows ? [
+  // Standard: "at functionName (C:\path\file.js:1:1)"
+  /\bat\s.+?\((?<path>[A-Z]:\\.+):\d+:\d+\)$/,
+  // direct: "at C:\path\file.js:1:1"
+  /\bat\s(?<path>[A-Z]:\\.+):\d+:\d+$/,
+  // UNC: "at functionName (\\server\share\path\file.js:1:1)"
+  /\bat\s.+?\((?<path>\\\\.+):\d+:\d+\)$/,
+  // direct: "at \\server\share\path\file.js:1:1"
+  /\bat\s(?<path>\\\\.+):\d+:\d+$/
+] : [
+  // Standard: "at functionName (/path/file.js:1:1)"
+  /\bat\s.+?\((?<path>\/.+?):\d+:\d+\)$/,
+  // Anonymous or direct: "at /path/file.js:1:1"
+  /\bat\s(.+[^/]\s)?(?<path>\/.+?):\d+:\d+$/
+];
+var MaybeUrlRE = /^[a-z]{2,5}:\/\//i;
+function extractCallerPath(stack) {
+  const frames = stack.split("\n").filter(Boolean);
+  const callerFrame = frames.findIndex(
+    (frame) => frame.includes("getCallerDirname")
+  );
+  if (callerFrame === -1) {
+    throw new Error("Invalid stack trace format: missing caller frame");
+  }
+  for (let i = callerFrame + 1; i < frames.length; i++) {
+    const frame = frames[i];
+    for (const pattern of patterns) {
+      const g = toS(frame).trim().match(pattern)?.groups;
+      if (g != null && isNotBlank(g["path"])) {
+        const path2 = g["path"];
+        if (MaybeUrlRE.test(path2)) {
+          try {
+            return new URL(path2).pathname;
+          } catch {
+          }
+        }
+        return path2;
+      }
+    }
+  }
+  throw new Error("Invalid stack trace format: no parsable frames");
+}
+
+// src/dirname.ts
+function _dirname() {
+  try {
+    if (typeof __dirname !== "undefined") return __dirname;
+  } catch {
+  }
+  return getCallerDirname();
+}
+
+// src/fs.ts
+import { opendir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+// src/async.ts
+import { availableParallelism } from "node:os";
+import { env } from "node:process";
+
+// src/number.ts
+function isNumber(value) {
+  return typeof value === "number" && isFinite(value);
+}
+var INTEGER_REGEX = /^-?\d+$/;
+function toInt(value) {
+  try {
+    if (value == null) return;
+    const s = String(value).trim();
+    return INTEGER_REGEX.test(s) ? parseInt(s) : void 0;
+  } catch {
+    return;
+  }
+}
+function gt0(value) {
+  return isNumber(value) && value > 0;
+}
+
+// src/units.ts
+var SecondMs = 1e3;
+var MinuteMs = 60 * SecondMs;
+var HourMs = 60 * MinuteMs;
+var DayMs = 24 * HourMs;
+var KiB = 1024;
+var MiB = 1024 * KiB;
+var GiB = 1024 * MiB;
+var TiB = 1024 * GiB;
+var f = 1023.995 / 1024;
+
 // src/async.ts
 var TimeoutError = class extends Error {
   constructor(message, captureStackTrace = true) {
@@ -128,6 +214,11 @@ async function withTimeout(opts) {
       desc + ": Expected timeoutMs to be > 0, but got " + timeoutMs
     );
   }
+  if (timeoutMs > DayMs) {
+    throw new TypeError(
+      desc + ": Invalid timeoutMs is too large: must be less than one day, but got " + timeoutMs
+    );
+  }
   if (timeoutMs === 0) {
     return opts.promise;
   }
@@ -178,20 +269,20 @@ async function mapConcurrent({
     while (executing.size >= maxConcurrency) {
       await Promise.race(executing);
     }
-    const p2 = results[index] = fn(item).catch((error) => error);
-    executing.add(p2);
-    p2.finally(() => executing.delete(p2));
+    const p = results[index] = fn(item).catch((error) => error);
+    executing.add(p);
+    p.finally(() => executing.delete(p));
   }
   return Promise.all(results);
 }
 
 // src/fs.ts
-async function statAsync(path, options) {
-  return stat(path, options);
+async function statAsync(path2, options) {
+  return stat(path2, options);
 }
-async function canStatAsync(path) {
+async function canStatAsync(path2) {
   try {
-    return null != await statAsync(path);
+    return null != await statAsync(path2);
   } catch {
     return false;
   }
@@ -220,7 +311,7 @@ async function _canReaddir(dir) {
 
 // src/hidden.ts
 import { rename } from "node:fs/promises";
-import { basename, dirname as dirname2, join as join2 } from "node:path";
+import { basename, dirname as dirname3, join as join2 } from "node:path";
 
 // src/object.ts
 function isObject(value) {
@@ -301,30 +392,28 @@ function toError(cause) {
 }
 
 // src/path.ts
-import { dirname, resolve as resolve2 } from "node:path";
-
-// src/platform.ts
-import { platform } from "node:os";
-var p = platform();
-var isLinux = p === "linux";
-var isWindows = p === "win32";
-var isMacOS = p === "darwin";
-
-// src/path.ts
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
 function normalizePath(mountPoint) {
   if (isBlank(mountPoint)) return void 0;
   const result = isWindows ? normalizeWindowsPath(mountPoint) : normalizePosixPath(mountPoint);
   return result != null ? resolve2(result) : void 0;
 }
 function normalizePosixPath(mountPoint) {
-  return isBlank(mountPoint) ? void 0 : mountPoint === "/" ? mountPoint : mountPoint.replace(/\/+$/, "");
+  if (isBlank(mountPoint)) return void 0;
+  if (mountPoint === "/") return mountPoint;
+  if (mountPoint[mountPoint.length - 1] !== "/") return mountPoint;
+  let end = mountPoint.length - 1;
+  while (end > 0 && mountPoint[end] === "/") {
+    end--;
+  }
+  return mountPoint.slice(0, end + 1);
 }
 function normalizeWindowsPath(mountPoint) {
   return /^[a-z]:$/i.test(mountPoint) ? mountPoint.toUpperCase() + "\\" : mountPoint;
 }
-function isRootDirectory(path) {
-  const n = normalizePath(path);
-  return n == null ? false : isWindows ? dirname(n) === n : n === "/";
+function isRootDirectory(path2) {
+  const n = normalizePath(path2);
+  return n == null ? false : isWindows ? dirname2(n) === n : n === "/";
 }
 
 // src/hidden.ts
@@ -352,23 +441,23 @@ var LocalSupport = HiddenSupportByPlatform[process.platform]?.supported ?? {
   dotPrefix: false,
   systemFlag: false
 };
-async function isHidden(pathname, nativeFn) {
+async function isHiddenImpl(pathname, nativeFn2) {
   const norm = normalizePath(pathname);
   if (norm == null) {
     throw new Error("Invalid pathname: " + JSON.stringify(pathname));
   }
-  return LocalSupport.dotPrefix && isPosixHidden(norm) || LocalSupport.systemFlag && isSystemHidden(norm, nativeFn);
+  return LocalSupport.dotPrefix && isPosixHidden(norm) || LocalSupport.systemFlag && isSystemHidden(norm, nativeFn2);
 }
-async function isHiddenRecursive(path, nativeFn) {
-  let norm = normalizePath(path);
+async function isHiddenRecursiveImpl(path2, nativeFn2) {
+  let norm = normalizePath(path2);
   if (norm == null) {
-    throw new Error("Invalid path: " + JSON.stringify(path));
+    throw new Error("Invalid path: " + JSON.stringify(path2));
   }
   while (!isRootDirectory(norm)) {
-    if (await isHidden(norm, nativeFn)) {
+    if (await isHiddenImpl(norm, nativeFn2)) {
       return true;
     }
-    norm = dirname2(norm);
+    norm = dirname3(norm);
   }
   return false;
 }
@@ -377,7 +466,7 @@ function createHiddenPosixPath(pathname, hidden) {
   if (norm == null) {
     throw new Error("Invalid pathname: " + JSON.stringify(pathname));
   }
-  const dir = dirname2(norm);
+  const dir = dirname3(norm);
   const srcBase = basename(norm).replace(/^\./, "");
   const dest = join2(dir, (hidden ? "." : "") + srcBase);
   return dest;
@@ -395,22 +484,22 @@ function isPosixHidden(pathname) {
   const b = basename(pathname);
   return b.startsWith(".") && b !== "." && b !== "..";
 }
-async function isSystemHidden(pathname, nativeFn) {
+async function isSystemHidden(pathname, nativeFn2) {
   if (!LocalSupport.systemFlag) {
     return false;
   }
   if (isWindows && isRootDirectory(pathname)) {
     return false;
   }
-  return await canStatAsync(pathname) && await (await nativeFn()).isHidden(pathname);
+  return await canStatAsync(pathname) && await (await nativeFn2()).isHidden(pathname);
 }
-async function getHiddenMetadata(pathname, nativeFn) {
+async function getHiddenMetadataImpl(pathname, nativeFn2) {
   const norm = normalizePath(pathname);
   if (norm == null) {
     throw new Error("Invalid pathname: " + JSON.stringify(pathname));
   }
   const dotPrefix = isPosixHidden(norm);
-  const systemFlag = await isSystemHidden(norm, nativeFn);
+  const systemFlag = await isSystemHidden(norm, nativeFn2);
   return {
     hidden: dotPrefix || systemFlag,
     dotPrefix,
@@ -418,7 +507,7 @@ async function getHiddenMetadata(pathname, nativeFn) {
     supported: LocalSupport
   };
 }
-async function setHidden(pathname, hide, method, nativeFn) {
+async function setHiddenImpl(pathname, hide, method, nativeFn2) {
   let norm = normalizePath(pathname);
   if (norm == null) {
     throw new Error("Invalid pathname: " + JSON.stringify(pathname));
@@ -450,7 +539,7 @@ async function setHidden(pathname, hide, method, nativeFn) {
     acted = true;
   }
   if (LocalSupport.systemFlag && (["all", "systemFlag"].includes(method) || !acted && method === "auto")) {
-    await (await nativeFn()).setHidden(norm, hide);
+    await (await nativeFn2()).setHidden(norm, hide);
     actions.systemFlag = true;
   }
   return { pathname: norm, actions };
@@ -473,6 +562,9 @@ var SystemPathPatternsDefault = [
   "/run/user/*/gvfs",
   "/snap/**",
   "/sys/**",
+  "/tmp",
+  "/var/tmp",
+  // we aren't including /tmp/**, as some people temporarily mount volumes there, like /tmp/project.
   "**/#snapshot",
   // Synology and Kubernetes volume snapshots
   // windows for linux:
@@ -542,6 +634,49 @@ function optionsWithDefaults(overrides = {}) {
   };
 }
 
+// src/string_enum.ts
+function stringEnum(...o) {
+  const set = new Set(o);
+  const dict = {};
+  for (const key of o) {
+    dict[key] = key;
+  }
+  return {
+    ...dict,
+    values: Object.freeze([...set]),
+    size: set.size,
+    get: (s) => s != null && set.has(s) ? s : void 0
+  };
+}
+
+// src/volume_health_status.ts
+var VolumeHealthStatuses = stringEnum(
+  "healthy",
+  "timeout",
+  "inaccessible",
+  "disconnected",
+  "unknown"
+);
+async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
+  try {
+    if (await canReaddirImpl(dir, timeoutMs)) {
+      return { status: VolumeHealthStatuses.healthy };
+    }
+  } catch (error) {
+    debug("[directoryStatus] %s: %s", dir, error);
+    let status = VolumeHealthStatuses.unknown;
+    if (error instanceof TimeoutError) {
+      status = VolumeHealthStatuses.timeout;
+    } else if (isObject(error) && error instanceof Error && "code" in error) {
+      if (error.code === "EPERM" || error.code === "EACCES") {
+        status = VolumeHealthStatuses.inaccessible;
+      }
+    }
+    return { status, error: toError(error) };
+  }
+  return { status: VolumeHealthStatuses.unknown };
+}
+
 // src/linux/dev_disk.ts
 import { readdir, readlink } from "node:fs/promises";
 import { join as join3, resolve as resolve3 } from "node:path";
@@ -599,8 +734,7 @@ import { readFile } from "node:fs/promises";
 
 // src/mount_point.ts
 function isMountPoint(obj) {
-  if (!isObject(obj)) return false;
-  return "mountPoint" in obj && isNotBlank(obj.mountPoint);
+  return isObject(obj) && "mountPoint" in obj && isNotBlank(obj.mountPoint);
 }
 
 // src/remote_info.ts
@@ -609,7 +743,7 @@ function isRemoteInfo(obj) {
   const { remoteHost, remoteShare } = obj;
   return isNotBlank(remoteHost) && isNotBlank(remoteShare);
 }
-var NETWORK_FS_TYPES = /* @__PURE__ */ new Set([
+var NETWORK_FS_TYPE_ARRAY = [
   "9p",
   "afp",
   "afs",
@@ -617,9 +751,6 @@ var NETWORK_FS_TYPES = /* @__PURE__ */ new Set([
   "ceph",
   "cifs",
   "ftp",
-  "fuse.cephfs",
-  "fuse.glusterfs",
-  "fuse.sshfs",
   "fuse",
   "gfs2",
   "glusterfs",
@@ -631,12 +762,31 @@ var NETWORK_FS_TYPES = /* @__PURE__ */ new Set([
   "smbfs",
   "sshfs",
   "webdav"
+];
+var NETWORK_FS_TYPES = new Set(NETWORK_FS_TYPE_ARRAY);
+var FS_TYPE_ALIASES = /* @__PURE__ */ new Map([
+  ["nfs1", "nfs"],
+  ["nfs2", "nfs"],
+  ["nfs3", "nfs"],
+  ["nfs4", "nfs4"],
+  ["fuse.sshfs", "sshfs"],
+  ["sshfs.fuse", "sshfs"],
+  ["davfs2", "webdav"],
+  ["davfs", "webdav"],
+  ["cifs.smb", "cifs"],
+  ["smbfs", "cifs"],
+  ["cephfs", "ceph"],
+  ["fuse.ceph", "ceph"],
+  ["fuse.cephfs", "ceph"],
+  ["rbd", "ceph"],
+  ["fuse.glusterfs", "glusterfs"]
 ]);
-function normalizeProtocol(protocol) {
-  return (protocol ?? "").toLowerCase().replace(/:$/, "");
+function normalizeFsType(fstype) {
+  const norm = toS(fstype).toLowerCase().replace(/:$/, "");
+  return FS_TYPE_ALIASES.get(norm) ?? norm;
 }
 function isRemoteFsType(fstype) {
-  return isNotBlank(fstype) && NETWORK_FS_TYPES.has(normalizeProtocol(fstype));
+  return isNotBlank(fstype) && NETWORK_FS_TYPES.has(normalizeFsType(fstype));
 }
 function parseURL(s) {
   try {
@@ -657,18 +807,22 @@ function extractRemoteInfo(fsSpec) {
       uri: fsSpec
     };
   }
-  const patterns = [
-    // CIFS/SMB pattern: //hostname/share or //user@host/share
+  const patterns2 = [
     {
+      // CIFS/SMB pattern: //hostname/share or //user@host/share
       regex: /^\/\/(?:(?<remoteUser>[^/@]+)@)?(?<remoteHost>[^/@]+)\/(?<remoteShare>.+)$/
     },
-    // NFS pattern: hostname:/share
     {
+      // sshfs pattern: sshfs#USER@HOST:REMOTE_PATH
+      regex: /^(?:(?<protocol>\w+)#)?(?<remoteUser>[^@]+)@(?<remoteHost>[^:]+):(?<remoteShare>.+)$/
+    },
+    {
+      // NFS pattern: hostname:/share
       protocol: "nfs",
       regex: /^(?<remoteHost>[^:]+):\/(?!\/)(?<remoteShare>.+)$/
     }
   ];
-  for (const { protocol, regex } of patterns) {
+  for (const { protocol, regex } of patterns2) {
     const o = compactValues({
       protocol,
       remote: true,
@@ -683,8 +837,8 @@ function extractRemoteInfo(fsSpec) {
     const parsed = new URL(fsSpec);
     if (parsed != null) {
       debug("[extractRemoteInfo] parsed URL: %o", parsed);
-      const protocol = normalizeProtocol(parsed.protocol);
-      if (!isRemoteFsType(protocol)) {
+      const fstype = normalizeFsType(parsed.protocol);
+      if (!isRemoteFsType(fstype)) {
         return {
           uri: fsSpec,
           remote: false
@@ -692,7 +846,7 @@ function extractRemoteInfo(fsSpec) {
       } else {
         return compactValues({
           uri: fsSpec,
-          protocol,
+          protocol: fstype,
           remote: true,
           remoteUser: parsed.username,
           remoteHost: parsed.hostname,
@@ -708,18 +862,18 @@ function extractRemoteInfo(fsSpec) {
 
 // src/glob.ts
 var cache = /* @__PURE__ */ new Map();
-function compileGlob(patterns) {
-  if (patterns == null || patterns.length === 0) {
+function compileGlob(patterns2) {
+  if (patterns2 == null || patterns2.length === 0) {
     return NeverMatchRE;
   }
-  const patternsKey = JSON.stringify(patterns);
+  const patternsKey = JSON.stringify(patterns2);
   {
     const prior = cache.get(patternsKey);
     if (prior != null) {
       return prior;
     }
   }
-  const sorted = patterns.slice().filter(isNotBlank).sort();
+  const sorted = patterns2.slice().filter(isNotBlank).sort();
   const sortedKey = JSON.stringify(sorted);
   {
     const prior = cache.get(sortedKey);
@@ -736,8 +890,8 @@ function compileGlob(patterns) {
   cache.set(sortedKey, result);
   return result;
 }
-function _compileGlob(patterns) {
-  const regexPatterns = patterns.map((pattern) => {
+function _compileGlob(patterns2) {
+  const regexPatterns = patterns2.map((pattern) => {
     let regex = "";
     let i = 0;
     while (i < pattern.length) {
@@ -843,7 +997,7 @@ function mountEntryToPartialVolumeMetadata(entry, options = {}) {
     mountFrom: entry.fs_spec,
     isSystemVolume: isSystemVolume(entry.fs_file, entry.fs_vfstype, options),
     remote: false,
-    // < default to false
+    // < default to false, but it may be overridden by extractRemoteInfo
     ...extractRemoteInfo(entry.fs_spec)
   };
 }
@@ -941,16 +1095,16 @@ async function getLinuxMtabMetadata(mountPoint, opts) {
 }
 
 // src/unc.ts
-function parseUNCPath(path) {
-  if (path == null || isBlank(path) || !isString(path)) {
+function parseUNCPath(path2) {
+  if (path2 == null || isBlank(path2) || !isString(path2)) {
     return;
   }
-  if (!path.startsWith("\\\\") && !path.startsWith("//")) {
+  if (!path2.startsWith("\\\\") && !path2.startsWith("//")) {
     return;
   }
-  const isForwardSlash = path.startsWith("//");
+  const isForwardSlash = path2.startsWith("//");
   const slashChar = isForwardSlash ? "/" : "\\";
-  const parts = path.slice(2).split(slashChar);
+  const parts = path2.slice(2).split(slashChar);
   if (parts.length < 2) {
     return;
   }
@@ -963,7 +1117,7 @@ function parseUNCPath(path) {
     return;
   }
   const wrongSlash = isForwardSlash ? "\\" : "/";
-  if (path.includes(wrongSlash)) {
+  if (path2.includes(wrongSlash)) {
     return;
   }
   return { remoteHost, remoteShare, remote: true };
@@ -975,49 +1129,6 @@ function extractUUID(uuid) {
   return toS(uuid).match(uuidRegex)?.[0];
 }
 
-// src/string_enum.ts
-function stringEnum(...o) {
-  const set = new Set(o);
-  const dict = {};
-  for (const key of o) {
-    dict[key] = key;
-  }
-  return {
-    ...dict,
-    values: Object.freeze([...set]),
-    size: set.size,
-    get: (s) => s != null && set.has(s) ? s : void 0
-  };
-}
-
-// src/volume_health_status.ts
-var VolumeHealthStatuses = stringEnum(
-  "healthy",
-  "timeout",
-  "inaccessible",
-  "disconnected",
-  "unknown"
-);
-async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
-  try {
-    if (await canReaddirImpl(dir, timeoutMs)) {
-      return { status: VolumeHealthStatuses.healthy };
-    }
-  } catch (error) {
-    debug("[directoryStatus] %s: %s", dir, error);
-    let status = VolumeHealthStatuses.unknown;
-    if (error instanceof TimeoutError) {
-      status = VolumeHealthStatuses.timeout;
-    } else if (isObject(error) && error instanceof Error && "code" in error) {
-      if (error.code === "EPERM" || error.code === "EACCES") {
-        status = VolumeHealthStatuses.inaccessible;
-      }
-    }
-    return { status, error: toError(error) };
-  }
-  return { status: VolumeHealthStatuses.unknown };
-}
-
 // src/array.ts
 function uniqBy(arr, keyFn) {
   const seen = /* @__PURE__ */ new Set();
@@ -1030,21 +1141,21 @@ function uniqBy(arr, keyFn) {
 }
 
 // src/volume_mount_points.ts
-async function getVolumeMountPoints(opts, nativeFn) {
-  const p2 = _getVolumeMountPoints(opts, nativeFn);
-  return isWindows ? p2 : withTimeout({ desc: "getVolumeMountPoints", ...opts, promise: p2 });
+async function getVolumeMountPointsImpl(opts, nativeFn2) {
+  const p = _getVolumeMountPoints(opts, nativeFn2);
+  return isWindows ? p : withTimeout({ desc: "getVolumeMountPoints", ...opts, promise: p });
 }
-async function _getVolumeMountPoints(o, nativeFn) {
+async function _getVolumeMountPoints(o, nativeFn2) {
   debug("[getVolumeMountPoints] gathering mount points with options: %o", o);
   const raw = await (isWindows || isMacOS ? (async () => {
     debug("[getVolumeMountPoints] using native implementation");
-    const points = await (await nativeFn()).getVolumeMountPoints(o);
+    const points = await (await nativeFn2()).getVolumeMountPoints(o);
     debug(
       "[getVolumeMountPoints] native returned %d mount points",
       points.length
     );
     return points;
-  })() : getLinuxMountPoints(nativeFn, o));
+  })() : getLinuxMountPoints(nativeFn2, o));
   debug("[getVolumeMountPoints] raw mount points: %o", raw);
   const compacted = raw.map((ea) => compactValues(ea)).filter((ea) => isNotBlank(ea.mountPoint));
   for (const ea of compacted) {
@@ -1082,20 +1193,20 @@ async function _getVolumeMountPoints(o, nativeFn) {
 }
 
 // src/volume_metadata.ts
-async function getVolumeMetadata(o, nativeFn) {
+async function getVolumeMetadataImpl(o, nativeFn2) {
   if (isBlank(o.mountPoint)) {
     throw new TypeError(
       "Invalid mountPoint: got " + JSON.stringify(o.mountPoint)
     );
   }
-  const p2 = _getVolumeMetadata(o, nativeFn);
-  return isWindows ? p2 : withTimeout({
+  const p = _getVolumeMetadata(o, nativeFn2);
+  return isWindows ? p : withTimeout({
     desc: "getVolumeMetadata()",
     timeoutMs: o.timeoutMs,
-    promise: p2
+    promise: p
   });
 }
-async function _getVolumeMetadata(o, nativeFn) {
+async function _getVolumeMetadata(o, nativeFn2) {
   o = optionsWithDefaults(o);
   const norm = normalizePath(o.mountPoint);
   if (norm == null) {
@@ -1137,7 +1248,7 @@ async function _getVolumeMetadata(o, nativeFn) {
     debug("[getVolumeMetadata] using device: %s", device);
   }
   debug("[getVolumeMetadata] requesting native metadata");
-  const metadata = await (await nativeFn()).getVolumeMetadata(o);
+  const metadata = await (await nativeFn2()).getVolumeMetadata(o);
   debug("[getVolumeMetadata] native metadata: %o", metadata);
   const remoteInfo = mtabInfo ?? extractRemoteInfo(metadata.uri) ?? extractRemoteInfo(metadata.mountFrom) ?? (isWindows ? parseUNCPath(o.mountPoint) : void 0);
   debug("[getVolumeMetadata] extracted remote info: %o", remoteInfo);
@@ -1168,10 +1279,10 @@ async function _getVolumeMetadata(o, nativeFn) {
   debug("[getVolumeMetadata] final result for %s: %o", o.mountPoint, result);
   return compactValues(result);
 }
-async function getAllVolumeMetadata(opts, nativeFn) {
+async function getAllVolumeMetadataImpl(opts, nativeFn2) {
   const o = optionsWithDefaults(opts);
   debug("[getAllVolumeMetadata] starting with options: %o", o);
-  const arr = await getVolumeMountPoints(o, nativeFn);
+  const arr = await getVolumeMountPointsImpl(o, nativeFn2);
   debug("[getAllVolumeMetadata] found %d mount points", arr.length);
   const unhealthyMountPoints = arr.filter(
     (ea) => ea.status != null && ea.status !== VolumeHealthStatuses.healthy
@@ -1201,7 +1312,7 @@ async function getAllVolumeMetadata(opts, nativeFn) {
   const results = await mapConcurrent({
     maxConcurrency: o.maxConcurrency,
     items: opts?.includeSystemVolumes ?? IncludeSystemVolumesDefault ? healthy : healthy.filter((ea) => !ea.isSystemVolume),
-    fn: async (mp) => getVolumeMetadata({ ...mp, ...o }, nativeFn).catch((error) => ({
+    fn: async (mp) => getVolumeMetadataImpl({ ...mp, ...o }, nativeFn2).catch((error) => ({
       mountPoint: mp.mountPoint,
       error
     }))
@@ -1219,49 +1330,52 @@ async function getAllVolumeMetadata(opts, nativeFn) {
   );
 }
 
-// src/setup.ts
-function setup(dirname4) {
-  const nativeFn = defer(async () => {
-    const start = Date.now();
-    try {
-      const dir = await findAncestorDir(dirname4, "binding.gyp");
-      if (dir == null) {
-        throw new Error(
-          "Could not find bindings.gyp in any ancestor directory of " + dirname4
-        );
-      }
-      const bindings = NodeGypBuild(dir);
-      bindings.setDebugLogging(isDebugEnabled());
-      bindings.setDebugPrefix(debugLogContext() + ":native");
-      return bindings;
-    } catch (error) {
-      debug("Loading native bindings failed: %s", error);
-      throw error;
-    } finally {
-      debug(`Native bindings took %d ms to load`, Date.now() - start);
+// src/index.ts
+var nativeFn = defer2(async () => {
+  const start = Date.now();
+  try {
+    const dirname4 = _dirname();
+    const dir = await findAncestorDir(dirname4, "binding.gyp");
+    if (dir == null) {
+      throw new Error(
+        "Could not find bindings.gyp in any ancestor directory of " + dirname4
+      );
     }
-  });
-  return {
-    getVolumeMountPoints: (opts = {}) => getVolumeMountPoints(optionsWithDefaults(opts), nativeFn),
-    getVolumeMetadata: (mountPoint, opts = {}) => getVolumeMetadata({ ...optionsWithDefaults(opts), mountPoint }, nativeFn),
-    getAllVolumeMetadata: (opts = {}) => getAllVolumeMetadata(optionsWithDefaults(opts), nativeFn),
-    isHidden: (pathname) => isHidden(pathname, nativeFn),
-    isHiddenRecursive: (pathname) => isHiddenRecursive(pathname, nativeFn),
-    getHiddenMetadata: (pathname) => getHiddenMetadata(pathname, nativeFn),
-    setHidden: (pathname, hidden, method = "auto") => setHidden(pathname, hidden, method, nativeFn)
-  };
+    const bindings = NodeGypBuild(dir);
+    bindings.setDebugLogging(isDebugEnabled());
+    bindings.setDebugPrefix(debugLogContext() + ":native");
+    return bindings;
+  } catch (error) {
+    debug("Loading native bindings failed: %s", error);
+    throw error;
+  } finally {
+    debug(`Native bindings took %d ms to load`, Date.now() - start);
+  }
+});
+function getVolumeMountPoints(opts) {
+  return getVolumeMountPointsImpl(optionsWithDefaults(opts), nativeFn);
+}
+function getVolumeMetadata(mountPoint, opts) {
+  return getVolumeMetadataImpl(
+    { ...optionsWithDefaults(opts), mountPoint },
+    nativeFn
+  );
+}
+function getAllVolumeMetadata(opts) {
+  return getAllVolumeMetadataImpl(optionsWithDefaults(opts), nativeFn);
+}
+function isHidden(pathname) {
+  return isHiddenImpl(pathname, nativeFn);
+}
+function isHiddenRecursive(pathname) {
+  return isHiddenRecursiveImpl(pathname, nativeFn);
+}
+function getHiddenMetadata(pathname) {
+  return getHiddenMetadataImpl(pathname, nativeFn);
+}
+function setHidden(pathname, hidden, method = "auto") {
+  return setHiddenImpl(pathname, hidden, method, nativeFn);
 }
-
-// src/index.mts
-var {
-  getVolumeMountPoints: getVolumeMountPoints2,
-  getVolumeMetadata: getVolumeMetadata2,
-  getAllVolumeMetadata: getAllVolumeMetadata2,
-  isHidden: isHidden2,
-  isHiddenRecursive: isHiddenRecursive2,
-  getHiddenMetadata: getHiddenMetadata2,
-  setHidden: setHidden2
-} = setup(dirname3(fileURLToPath(import.meta.url)));
 export {
   IncludeSystemVolumesDefault,
   LinuxMountTablePathsDefault,
@@ -1270,13 +1384,13 @@ export {
   SystemPathPatternsDefault,
   TimeoutMsDefault,
   VolumeHealthStatuses,
-  getAllVolumeMetadata2 as getAllVolumeMetadata,
-  getHiddenMetadata2 as getHiddenMetadata,
-  getVolumeMetadata2 as getVolumeMetadata,
-  getVolumeMountPoints2 as getVolumeMountPoints,
-  isHidden2 as isHidden,
-  isHiddenRecursive2 as isHiddenRecursive,
+  getAllVolumeMetadata,
+  getHiddenMetadata,
+  getVolumeMetadata,
+  getVolumeMountPoints,
+  isHidden,
+  isHiddenRecursive,
   optionsWithDefaults,
-  setHidden2 as setHidden
+  setHidden
 };
 //# sourceMappingURL=index.mjs.map