@photostructure/fs-metadata 0.3.1 → 0.3.3

package/dist/index.cjs

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.cts
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
   IncludeSystemVolumesDefault: () => IncludeSystemVolumesDefault,
@@ -37,41 +37,24 @@ __export(index_exports, {
   SystemPathPatternsDefault: () => SystemPathPatternsDefault,
   TimeoutMsDefault: () => TimeoutMsDefault,
   VolumeHealthStatuses: () => VolumeHealthStatuses,
-  getAllVolumeMetadata: () => getAllVolumeMetadata2,
-  getHiddenMetadata: () => getHiddenMetadata2,
-  getVolumeMetadata: () => getVolumeMetadata2,
-  getVolumeMountPoints: () => getVolumeMountPoints2,
-  isHidden: () => isHidden2,
-  isHiddenRecursive: () => isHiddenRecursive2,
+  getAllVolumeMetadata: () => getAllVolumeMetadata,
+  getHiddenMetadata: () => getHiddenMetadata,
+  getVolumeMetadata: () => getVolumeMetadata,
+  getVolumeMountPoints: () => getVolumeMountPoints,
+  isHidden: () => isHidden,
+  isHiddenRecursive: () => isHiddenRecursive,
   optionsWithDefaults: () => optionsWithDefaults,
-  setHidden: () => setHidden2
+  setHidden: () => setHidden
 });
 module.exports = __toCommonJS(index_exports);
-
-// src/setup.ts
 var import_node_gyp_build = __toESM(require("node-gyp-build"));
 
 // src/debuglog.ts
 var import_node_util = require("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 ((0, import_node_util.debuglog)(ea).enabled) {
@@ -93,32 +76,32 @@ function debug(msg, ...args) {
   process.stderr.write(timestamp + (0, import_node_util.format)(msg, ...args) + "\n");
 }
 
-// src/fs.ts
-var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
+// 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/stack_path.ts
 var import_node_path = require("path");
 
-// src/async.ts
-var import_node_os = require("os");
+// src/platform.ts
 var import_node_process = require("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;
-}
+var isLinux = import_node_process.platform === "linux";
+var isWindows = import_node_process.platform === "win32";
+var isMacOS = import_node_process.platform === "darwin";
+var isArm = isLinux && import_node_process.arch.startsWith("arm");
 
 // src/string.ts
 function isString(input) {
@@ -152,6 +135,104 @@ 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 (0, import_node_path.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 path = g["path"];
+        if (MaybeUrlRE.test(path)) {
+          try {
+            return new URL(path).pathname;
+          } catch {
+          }
+        }
+        return path;
+      }
+    }
+  }
+  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
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/async.ts
+var import_node_os = require("os");
+var import_node_process2 = require("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) {
@@ -175,13 +256,18 @@ 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;
   }
   const timeoutError = new TimeoutError(
     `${desc}: timeout after ${timeoutMs}ms`
   );
-  if (import_node_process.env["NODE_ENV"] === "test" && timeoutMs === 1) {
+  if (import_node_process2.env["NODE_ENV"] === "test" && timeoutMs === 1) {
     timeoutError.message += "(timeout test)";
     opts.promise.catch(() => {
     });
@@ -225,9 +311,9 @@ 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);
 }
@@ -244,13 +330,13 @@ async function canStatAsync(path) {
   }
 }
 async function findAncestorDir(dir, file) {
-  dir = (0, import_node_path.resolve)(dir);
+  dir = (0, import_node_path2.resolve)(dir);
   try {
-    const s = await statAsync((0, import_node_path.join)(dir, file));
+    const s = await statAsync((0, import_node_path2.join)(dir, file));
     if (s.isFile()) return dir;
   } catch {
   }
-  const parent = (0, import_node_path.resolve)(dir, "..");
+  const parent = (0, import_node_path2.resolve)(dir, "..");
   return parent === dir ? void 0 : findAncestorDir(parent, file);
 }
 async function canReaddir(dir, timeoutMs) {
@@ -261,19 +347,13 @@ async function canReaddir(dir, timeoutMs) {
   });
 }
 async function _canReaddir(dir) {
-  let d = void 0;
-  try {
-    d = await (0, import_promises.opendir)(dir);
-    await d.read();
-    return true;
-  } finally {
-    if (d != null) void d.close();
-  }
+  await (await (0, import_promises.opendir)(dir)).close();
+  return true;
 }
 
 // src/hidden.ts
 var import_promises2 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 
 // src/object.ts
 function isObject(value) {
@@ -354,30 +434,28 @@ function toError(cause) {
 }
 
 // src/path.ts
-var import_node_path2 = require("path");
-
-// src/platform.ts
-var import_node_os2 = require("os");
-var p = (0, import_node_os2.platform)();
-var isLinux = p === "linux";
-var isWindows = p === "win32";
-var isMacOS = p === "darwin";
-
-// src/path.ts
+var import_node_path3 = require("path");
 function normalizePath(mountPoint) {
   if (isBlank(mountPoint)) return void 0;
   const result = isWindows ? normalizeWindowsPath(mountPoint) : normalizePosixPath(mountPoint);
-  return result != null ? (0, import_node_path2.resolve)(result) : void 0;
+  return result != null ? (0, import_node_path3.resolve)(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 ? (0, import_node_path2.dirname)(n) === n : n === "/";
+  return n == null ? false : isWindows ? (0, import_node_path3.dirname)(n) === n : n === "/";
 }
 
 // src/hidden.ts
@@ -405,23 +483,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) {
+async function isHiddenRecursiveImpl(path, nativeFn2) {
   let norm = normalizePath(path);
   if (norm == null) {
     throw new Error("Invalid path: " + JSON.stringify(path));
   }
   while (!isRootDirectory(norm)) {
-    if (await isHidden(norm, nativeFn)) {
+    if (await isHiddenImpl(norm, nativeFn2)) {
       return true;
     }
-    norm = (0, import_node_path3.dirname)(norm);
+    norm = (0, import_node_path4.dirname)(norm);
   }
   return false;
 }
@@ -430,9 +508,9 @@ function createHiddenPosixPath(pathname, hidden) {
   if (norm == null) {
     throw new Error("Invalid pathname: " + JSON.stringify(pathname));
   }
-  const dir = (0, import_node_path3.dirname)(norm);
-  const srcBase = (0, import_node_path3.basename)(norm).replace(/^\./, "");
-  const dest = (0, import_node_path3.join)(dir, (hidden ? "." : "") + srcBase);
+  const dir = (0, import_node_path4.dirname)(norm);
+  const srcBase = (0, import_node_path4.basename)(norm).replace(/^\./, "");
+  const dest = (0, import_node_path4.join)(dir, (hidden ? "." : "") + srcBase);
   return dest;
 }
 async function setHiddenPosix(pathname, hidden) {
@@ -445,25 +523,25 @@ async function setHiddenPosix(pathname, hidden) {
 }
 function isPosixHidden(pathname) {
   if (!LocalSupport.dotPrefix) return false;
-  const b = (0, import_node_path3.basename)(pathname);
+  const b = (0, import_node_path4.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,
@@ -471,7 +549,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));
@@ -503,14 +581,14 @@ 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 };
 }
 
 // src/options.ts
-var import_node_os3 = require("os");
+var import_node_os2 = require("os");
 var TimeoutMsDefault = 5e3;
 var SystemPathPatternsDefault = [
   "/boot",
@@ -526,6 +604,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:
@@ -577,7 +658,7 @@ var LinuxMountTablePathsDefault = [
 var IncludeSystemVolumesDefault = isWindows;
 var OptionsDefault = {
   timeoutMs: TimeoutMsDefault,
-  maxConcurrency: (0, import_node_os3.availableParallelism)(),
+  maxConcurrency: (0, import_node_os2.availableParallelism)(),
   systemPathPatterns: [...SystemPathPatternsDefault],
   systemFsTypes: [...SystemFsTypesDefault],
   linuxMountTablePaths: [...LinuxMountTablePathsDefault],
@@ -595,14 +676,57 @@ 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
 var import_promises3 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 async function getUuidFromDevDisk(devicePath) {
   try {
     const result = await getBasenameLinkedTo(
       "/dev/disk/by-uuid",
-      (0, import_node_path4.resolve)(devicePath)
+      (0, import_node_path5.resolve)(devicePath)
     );
     debug("[getUuidFromDevDisk] result: %o", result);
     return result;
@@ -615,7 +739,7 @@ async function getLabelFromDevDisk(devicePath) {
   try {
     const result = await getBasenameLinkedTo(
       "/dev/disk/by-label",
-      (0, import_node_path4.resolve)(devicePath)
+      (0, import_node_path5.resolve)(devicePath)
     );
     debug("[getLabelFromDevDisk] result: %o", result);
     return result;
@@ -636,9 +760,9 @@ async function* readLinks(directory) {
   for (const dirent of await (0, import_promises3.readdir)(directory, { withFileTypes: true })) {
     if (dirent.isSymbolicLink()) {
       try {
-        const linkTarget = (0, import_node_path4.resolve)(
+        const linkTarget = (0, import_node_path5.resolve)(
           directory,
-          await (0, import_promises3.readlink)((0, import_node_path4.join)(directory, dirent.name))
+          await (0, import_promises3.readlink)((0, import_node_path5.join)(directory, dirent.name))
         );
         yield { dirent, linkTarget };
       } catch {
@@ -652,8 +776,7 @@ var import_promises4 = require("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
@@ -662,7 +785,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",
@@ -670,9 +793,6 @@ var NETWORK_FS_TYPES = /* @__PURE__ */ new Set([
   "ceph",
   "cifs",
   "ftp",
-  "fuse.cephfs",
-  "fuse.glusterfs",
-  "fuse.sshfs",
   "fuse",
   "gfs2",
   "glusterfs",
@@ -684,12 +804,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 {
@@ -710,18 +849,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,
@@ -736,8 +879,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
@@ -745,7 +888,7 @@ function extractRemoteInfo(fsSpec) {
       } else {
         return compactValues({
           uri: fsSpec,
-          protocol,
+          protocol: fstype,
           remote: true,
           remoteUser: parsed.username,
           remoteHost: parsed.hostname,
@@ -761,18 +904,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);
@@ -789,8 +932,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) {
@@ -896,7 +1039,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)
   };
 }
@@ -1028,49 +1171,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();
@@ -1083,21 +1183,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) {
@@ -1135,20 +1235,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) {
@@ -1190,7 +1290,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);
@@ -1221,10 +1321,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
@@ -1254,7 +1354,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
     }))
@@ -1272,49 +1372,52 @@ async function getAllVolumeMetadata(opts, nativeFn) {
   );
 }
 
-// src/setup.ts
-function setup(dirname3) {
-  const nativeFn = defer(async () => {
-    const start = Date.now();
-    try {
-      const dir = await findAncestorDir(dirname3, "binding.gyp");
-      if (dir == null) {
-        throw new Error(
-          "Could not find bindings.gyp in any ancestor directory of " + dirname3
-        );
-      }
-      const bindings = (0, import_node_gyp_build.default)(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 = (0, import_node_gyp_build.default)(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.cts
-var {
-  getVolumeMountPoints: getVolumeMountPoints2,
-  getVolumeMetadata: getVolumeMetadata2,
-  getAllVolumeMetadata: getAllVolumeMetadata2,
-  isHidden: isHidden2,
-  isHiddenRecursive: isHiddenRecursive2,
-  getHiddenMetadata: getHiddenMetadata2,
-  setHidden: setHidden2
-} = setup(__dirname);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   IncludeSystemVolumesDefault,