@photostructure/fs-metadata 1.3.0 → 1.4.1

package/src/darwin/get_mount_point.cpp

@@ -7,6 +7,7 @@
 #include "../common/error_utils.h"
 #include "../common/fd_guard.h"
 #include "../common/path_security.h"
+#include "../common/shutdown.h"
 
 #include <fcntl.h>
 #include <string>
@@ -16,11 +17,11 @@
 
 namespace FSMeta {
 
-class GetMountPointWorker : public Napi::AsyncWorker {
+class GetMountPointWorker : public SafeAsyncWorker {
 public:
   GetMountPointWorker(const std::string &path,
                       const Napi::Promise::Deferred &deferred)
-      : Napi::AsyncWorker(deferred.Env()), path_(path), deferred_(deferred) {}
+      : SafeAsyncWorker(deferred.Env()), path_(path), deferred_(deferred) {}
 
   void Execute() override {
     DEBUG_LOG("[GetMountPointWorker] Executing for path: %s", path_.c_str());
@@ -65,11 +66,12 @@ public:
 
   void OnOK() override {
     Napi::HandleScope scope(Env());
-    deferred_.Resolve(Napi::String::New(Env(), result_));
+    SafeResolve(deferred_, Napi::String::New(Env(), result_));
   }
 
   void OnError(const Napi::Error &error) override {
-    deferred_.Reject(error.Value());
+    Napi::HandleScope scope(Env());
+    SafeReject(deferred_, error.Value());
   }
 
 private:

package/src/darwin/hidden.cpp

@@ -4,6 +4,7 @@
 #include "../common/error_utils.h"
 #include "../common/fd_guard.h"
 #include "../common/path_security.h"
+#include "../common/shutdown.h"
 #include <fcntl.h>  // for open(), O_RDONLY, O_CLOEXEC
 #include <string.h> // for strcmp
 #include <sys/mount.h>
@@ -14,7 +15,7 @@ namespace FSMeta {
 
 GetHiddenWorker::GetHiddenWorker(std::string path,
                                  Napi::Promise::Deferred deferred)
-    : Napi::AsyncWorker(deferred.Env()), path_(std::move(path)),
+    : SafeAsyncWorker(deferred.Env()), path_(std::move(path)),
       deferred_(deferred), is_hidden_(false) {
   DEBUG_LOG("[GetHiddenWorker] created for path: %s", path_.c_str());
 }
@@ -81,12 +82,12 @@ void GetHiddenWorker::Execute() {
 void GetHiddenWorker::OnOK() {
   Napi::HandleScope scope(Env());
   auto env = Env();
-  deferred_.Resolve(Napi::Boolean::New(env, is_hidden_));
+  SafeResolve(deferred_, Napi::Boolean::New(env, is_hidden_));
 }
 
 void GetHiddenWorker::OnError(const Napi::Error &error) {
   Napi::HandleScope scope(Env());
-  deferred_.Reject(error.Value());
+  SafeReject(deferred_, error.Value());
 }
 
 Napi::Promise GetHiddenAttribute(const Napi::CallbackInfo &info) {
@@ -111,8 +112,8 @@ Napi::Promise GetHiddenAttribute(const Napi::CallbackInfo &info) {
 
 SetHiddenWorker::SetHiddenWorker(std::string path, bool hidden,
                                  Napi::Promise::Deferred deferred)
-    : Napi::AsyncWorker(deferred.Env()), path_(std::move(path)),
-      hidden_(hidden), deferred_(deferred) {
+    : SafeAsyncWorker(deferred.Env()), path_(std::move(path)), hidden_(hidden),
+      deferred_(deferred) {
   DEBUG_LOG("[SetHiddenWorker] created for path: %s, hidden: %d", path_.c_str(),
             hidden_);
 }
@@ -206,12 +207,12 @@ void SetHiddenWorker::Execute() {
 void SetHiddenWorker::OnOK() {
   Napi::HandleScope scope(Env());
   auto env = Env();
-  deferred_.Resolve(env.Undefined());
+  SafeResolve(deferred_, env.Undefined());
 }
 
 void SetHiddenWorker::OnError(const Napi::Error &error) {
   Napi::HandleScope scope(Env());
-  deferred_.Reject(error.Value());
+  SafeReject(deferred_, error.Value());
 }
 
 Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
@@ -238,4 +239,4 @@ Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/darwin/hidden.h

@@ -1,11 +1,12 @@
 // src/darwin/hidden.h
 #pragma once
 #include "../common/hidden.h"
+#include "../common/shutdown.h"
 #include <napi.h>
 
 namespace FSMeta {
 
-class GetHiddenWorker : public Napi::AsyncWorker {
+class GetHiddenWorker : public SafeAsyncWorker {
 public:
   GetHiddenWorker(std::string path, Napi::Promise::Deferred deferred);
   void Execute() override;
@@ -18,7 +19,7 @@ private:
   bool is_hidden_;
 };
 
-class SetHiddenWorker : public Napi::AsyncWorker {
+class SetHiddenWorker : public SafeAsyncWorker {
 public:
   SetHiddenWorker(std::string path, bool hidden,
                   Napi::Promise::Deferred deferred);
@@ -32,4 +33,4 @@ private:
   Napi::Promise::Deferred deferred_;
 };
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/darwin/volume_metadata.cpp

@@ -4,6 +4,7 @@
 #include "../common/debug_log.h"
 #include "../common/fd_guard.h"
 #include "../common/path_security.h"
+#include "../common/shutdown.h"
 #include "../common/volume_utils.h"
 #include "./da_mutex.h"
 #include "./fs_meta.h"
@@ -76,6 +77,11 @@ public:
   void Execute() override {
     DEBUG_LOG("[GetVolumeMetadataWorker] Executing for mount point: %s",
               mountPoint.c_str());
+    if (IsShuttingDown()) {
+      // Avoid kicking off blocking IOKit/DA calls during env teardown.
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       // Validate and canonicalize mount point using realpath()
       // This follows Apple's Secure Coding Guide recommendations
@@ -207,6 +213,14 @@ private:
     DEBUG_LOG("[GetVolumeMetadataWorker] Getting Disk Arbitration info for: %s",
               mountPoint.c_str());
 
+    if (IsShuttingDown()) {
+      // IOServiceGetMatchingService is uncancellable; if we're already in
+      // teardown, surface a partial result rather than block FreeEnvironment.
+      metadata.status = "partial";
+      metadata.error = "shutdown in progress";
+      return;
+    }
+
     // Check if this is a network filesystem
     if (metadata.fstype == "smbfs" || metadata.fstype == "nfs" ||
         metadata.fstype == "afpfs" || metadata.fstype == "webdav") {
@@ -370,4 +384,4 @@ Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/darwin/volume_mount_points.cpp

@@ -2,6 +2,7 @@
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
 #include "../common/error_utils.h"
+#include "../common/shutdown.h"
 #include "./da_mutex.h"
 #include "./fs_meta.h"
 #include "./raii_utils.h"
@@ -13,7 +14,7 @@
 
 namespace FSMeta {
 
-class GetVolumeMountPointsWorker : public Napi::AsyncWorker {
+class GetVolumeMountPointsWorker : public SafeAsyncWorker {
 private:
   Napi::Promise::Deferred deferred_;
   std::vector<MountPoint> mountPoints_;
@@ -22,11 +23,15 @@ private:
 public:
   GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred,
                              uint32_t timeoutMs = 5000)
-      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred),
+      : SafeAsyncWorker(deferred.Env()), deferred_(deferred),
         timeoutMs_(timeoutMs) {}
 
   void Execute() override {
     DEBUG_LOG("[GetVolumeMountPointsWorker] Executing");
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       MountBufferRAII mntbuf;
       // Use MNT_NOWAIT for better performance - we'll verify accessibility
@@ -57,6 +62,10 @@ public:
       {
         std::lock_guard<std::mutex> lock(g_diskArbitrationMutex);
 
+        if (IsShuttingDown()) {
+          return;
+        }
+
         DASessionRAII session(DASessionCreate(kCFAllocatorDefault));
         if (session.isValid()) {
           static dispatch_queue_t da_queue = dispatch_queue_create(
@@ -66,6 +75,10 @@ public:
         }
 
         for (int j = 0; j < count; j++) {
+          if (IsShuttingDown()) {
+            return;
+          }
+
           MountPoint mp;
           mp.mountPoint = mntbuf.get()[j].f_mntonname;
           mp.fstype = mntbuf.get()[j].f_fstypename;
@@ -88,6 +101,10 @@ public:
       const size_t maxConcurrentChecks = 4; // Limit concurrent access checks
 
       for (size_t i = 0; i < allMountPoints.size(); i += maxConcurrentChecks) {
+        if (IsShuttingDown()) {
+          return;
+        }
+
         std::vector<std::future<std::pair<std::string, bool>>> futures;
         std::vector<MountPoint *> batchPtrs;
 
@@ -182,7 +199,12 @@ public:
       result[i] = mountPoints_[i].ToObject(env);
     }
 
-    deferred_.Resolve(result);
+    SafeResolve(deferred_, result);
+  }
+
+  void OnError(const Napi::Error &error) override {
+    Napi::HandleScope scope(Env());
+    SafeReject(deferred_, error.Value());
   }
 };
 
@@ -202,4 +224,4 @@ Napi::Promise GetVolumeMountPoints(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/linux/mount_points.ts

@@ -2,69 +2,35 @@
 import { readFile } from "node:fs/promises";
 import { debug } from "../debuglog";
 import { toError, WrappedError } from "../error";
-import { isMountPoint } from "../mount_point";
-import { compactValues } from "../object";
 import { optionsWithDefaults } from "../options";
 import { type MountPoint } from "../types/mount_point";
-import type { NativeBindingsFn } from "../types/native_bindings";
 import type { Options } from "../types/options";
 import { MountEntry, mountEntryToMountPoint, parseMtab } from "./mtab";
 
 export async function getLinuxMountPoints(
-  native: NativeBindingsFn,
   opts?: Pick<Options, "linuxMountTablePaths">,
 ): Promise<MountPoint[]> {
   const o = optionsWithDefaults(opts);
-  const raw: MountPoint[] = [];
-  try {
-    // Get GIO mounts if available from native module
-    const arr = await (await native()).getGioMountPoints?.();
-    debug("[getLinuxMountPoints] GIO mount points: %o", arr);
-    if (arr != null) raw.push(...arr);
-  } catch (error) {
-    debug("Failed to get GIO mount points: %s", error);
-    // GIO support not compiled in or failed, continue with just mtab mounts
-  }
-
   let cause: Error | undefined;
   for (const input of o.linuxMountTablePaths) {
     try {
       const mtabContent = await readFile(input, "utf8");
-      const arr = parseMtab(mtabContent)
+      const results = parseMtab(mtabContent)
         .map((ea) => mountEntryToMountPoint(ea))
         .filter((ea) => ea != null);
-      debug("[getLinuxMountPoints] %s mount points: %o", input, arr);
-      if (arr.length > 0) {
-        raw.push(...arr);
-        break;
+      debug("[getLinuxMountPoints] %s mount points: %o", input, results);
+      if (results.length > 0) {
+        return results;
       }
     } catch (error) {
       cause ??= toError(error);
     }
   }
 
-  const byMountPoint = new Map<string, MountPoint>();
-  for (const ea of raw) {
-    const prior = byMountPoint.get(ea.mountPoint);
-    const merged = { ...compactValues(prior), ...compactValues(ea) };
-    if (isMountPoint(merged)) {
-      byMountPoint.set(merged.mountPoint, merged);
-    }
-  }
-
-  if (byMountPoint.size === 0) {
-    throw new WrappedError(
-      `Failed to find any mount points (tried: ${JSON.stringify(o.linuxMountTablePaths)})`,
-      { cause },
-    );
-  }
-
-  const results = [...byMountPoint.values()];
-  debug("[getLinuxMountPoints] %o", {
-    results: results.map((ea) => ea.mountPoint),
-  });
-
-  return results;
+  throw new WrappedError(
+    `Failed to find any mount points (tried: ${JSON.stringify(o.linuxMountTablePaths)})`,
+    { cause },
+  );
 }
 
 export async function getLinuxMtabMetadata(

package/src/linux/volume_metadata.cpp

@@ -12,10 +12,6 @@
 #include <sys/statvfs.h>
 #include <unistd.h>
 
-#ifdef ENABLE_GIO
-#include "gio_volume_metadata.h"
-#endif
-
 namespace FSMeta {
 
 class LinuxMetadataWorker : public MetadataWorkerBase {
@@ -31,6 +27,10 @@ public:
   }
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       DEBUG_LOG("[LinuxMetadataWorker] starting statvfs for %s",
                 mountPoint.c_str());
@@ -113,18 +113,6 @@ public:
                 mountPoint.c_str(), metadata.size / 1e9,
                 metadata.available / 1e9);
 
-#ifdef ENABLE_GIO
-      try {
-        DEBUG_LOG("[LinuxMetadataWorker] collecting GIO metadata for %s",
-                  validated_mount_point.c_str());
-        gio::addMountMetadata(validated_mount_point, metadata);
-      } catch (const std::exception &e) {
-        DEBUG_LOG("[LinuxMetadataWorker] GIO error for %s: %s",
-                  validated_mount_point.c_str(), e.what());
-        metadata.status = std::string("GIO warning: ") + e.what();
-      }
-#endif
-
       if (!options_.device.empty()) {
         DEBUG_LOG("[LinuxMetadataWorker] getting blkid info for device %s",
                   options_.device.c_str());
@@ -197,4 +185,4 @@ Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/mount_point_for_path.ts

@@ -48,7 +48,7 @@ export async function getMountPointForPathImpl(
     throw new Error("getMountPoint native function unavailable");
   }
 
-  // Linux/Windows: device ID matching + path prefix tiebreaker
+  // Linux/Windows: device ID filtering + longest ancestor path matching
   debug("[getMountPointForPath] using device matching for %s", resolved);
   return findMountPointByDeviceId(resolved, resolvedStat, opts, nativeFn);
 }

package/src/types/mount_point.ts

@@ -29,7 +29,7 @@ export interface MountPoint {
    * verifyVolume`.
    *
    * If there are non-critical errors while extracting metadata, those error
-   * messages may be added to this field (say, from blkid or gio).
+   * messages may be added to this field (say, from blkid).
    *
    * @see {@link VolumeHealthStatuses} for values returned by Windows.
    */

package/src/types/native_bindings.ts

@@ -43,11 +43,6 @@ export interface NativeBindings {
     options?: Pick<Options, "timeoutMs">,
   ): Promise<MountPoint[]>;
 
-  /**
-   * This is only available on Linux, and only if libglib-2.0 is installed.
-   */
-  getGioMountPoints?(): Promise<MountPoint[]>;
-
   /**
    * This is only a partial implementation for most platforms, to minimize
    * native code when possible. The javascript side handles a bunch of

package/src/volume_metadata.ts

@@ -95,7 +95,8 @@ async function _getVolumeMetadata(
       }
     } catch (err) {
       debug("[getVolumeMetadata] failed to get mtab info: " + err);
-      // this may be a GIO mount. Ignore the error and continue.
+      // Mtab lookup can fail for transient mounts or race conditions.
+      // Ignore and continue with whatever the native call returns.
     }
   }
 
@@ -140,7 +141,7 @@ async function _getVolumeMetadata(
     remote,
   }) as VolumeMetadata;
 
-  // Backfill if blkid or gio failed us:
+  // Backfill if blkid failed us:
   if (isLinux && isNotBlank(device)) {
     // Sometimes blkid doesn't have the UUID in cache. Try to get it from
     // /dev/disk/by-uuid:
@@ -209,7 +210,7 @@ export async function getVolumeMetadataForPathImpl(
 
   // Linux/Windows: stat().dev is reliable (no firmlinks). Find the mount point
   // by comparing device IDs, using path prefix as a tiebreaker for bind mounts
-  // or GIO mounts that share the same device id.
+  // or GVfs/FUSE mounts that share the same device id.
   const mountPoint = await findMountPointByDeviceId(
     resolved,
     resolvedStat,
@@ -221,12 +222,18 @@ export async function getVolumeMetadataForPathImpl(
 }
 
 /**
- * Find the mount point for a resolved path using device ID matching.
+ * Find the mount point for a resolved path using device ID + path ancestry.
  * Used on Linux and Windows where stat().dev is reliable (no firmlinks).
  *
- * Compares device IDs of mount points against the target path's device ID,
- * using path prefix as a tiebreaker for bind mounts or GIO mounts that share
- * the same device id. The longest prefix match wins.
+ * Device ID filters out unrelated filesystems. Among same-device mount points,
+ * ancestor-path matches (mount point is a parent of `resolved`) are strongly
+ * preferred over device-only matches — GVfs/FUSE mounts on Linux can share
+ * the same device ID across unrelated volumes (e.g. multiple SMB shares
+ * under /run/user/.../gvfs/), so device ID alone is ambiguous. The longest
+ * ancestor wins.
+ *
+ * The device-only fallback (`deviceMatches`) exists for bind mounts where the
+ * canonical mount point may not be a path ancestor of the target.
  */
 export async function findMountPointByDeviceId(
   resolved: string,
@@ -261,6 +268,8 @@ export async function findMountPointByDeviceId(
     }),
   );
 
+  // Prefer ancestor matches — they're unambiguous. Fall back to device-only
+  // matches only when the mount point isn't an ancestor (e.g. bind mounts).
   const candidates = prefixMatches.length > 0 ? prefixMatches : deviceMatches;
   if (candidates.length === 0) {
     throw new Error(

package/src/volume_mount_points.ts

@@ -51,7 +51,7 @@ async function _getVolumeMountPoints(
         );
         return points;
       })()
-    : getLinuxMountPoints(nativeFn, o));
+    : getLinuxMountPoints(o));
 
   debug("[getVolumeMountPoints] raw mount points: %o", raw);
 

package/src/windows/hidden.cpp

@@ -1,6 +1,7 @@
 // src/windows/hidden.cpp
 #include "hidden.h"
 #include "../common/debug_log.h"
+#include "../common/shutdown.h"
 #include "error_utils.h"
 #include "security_utils.h"
 
@@ -36,14 +37,14 @@ public:
 };
 } // anonymous namespace
 
-class GetHiddenWorker : public Napi::AsyncWorker {
+class GetHiddenWorker : public SafeAsyncWorker {
   const std::string path;
   bool result = false;
   Napi::Promise::Deferred deferred;
 
 public:
   GetHiddenWorker(Napi::Env env, std::string p, Napi::Promise::Deferred def)
-      : Napi::AsyncWorker(env), path(std::move(p)), deferred(def) {}
+      : SafeAsyncWorker(env), path(std::move(p)), deferred(def) {}
 
   void Execute() override {
     try {
@@ -104,17 +105,17 @@ public:
     DEBUG_LOG("[GetHiddenWorker] OnOK called, result=%s",
               result ? "true" : "false");
     Napi::HandleScope scope(Env());
-    deferred.Resolve(Napi::Boolean::New(Env(), result));
+    SafeResolve(deferred, Napi::Boolean::New(Env(), result));
   }
 
   void OnError(const Napi::Error &e) override {
     DEBUG_LOG("[GetHiddenWorker] OnError called with: %s", e.Message().c_str());
     Napi::HandleScope scope(Env());
-    deferred.Reject(e.Value());
+    SafeReject(deferred, e.Value());
   }
 };
 
-class SetHiddenWorker : public Napi::AsyncWorker {
+class SetHiddenWorker : public SafeAsyncWorker {
   const std::string path;
   const bool value;
   Napi::Promise::Deferred deferred;
@@ -122,7 +123,7 @@ class SetHiddenWorker : public Napi::AsyncWorker {
 public:
   SetHiddenWorker(Napi::Env env, std::string p, bool v,
                   Napi::Promise::Deferred def)
-      : Napi::AsyncWorker(env), path(std::move(p)), value(v), deferred(def) {}
+      : SafeAsyncWorker(env), path(std::move(p)), value(v), deferred(def) {}
 
   void Execute() override {
     try {
@@ -144,12 +145,12 @@ public:
 
   void OnOK() override {
     Napi::HandleScope scope(Env());
-    deferred.Resolve(Napi::Boolean::New(Env(), true));
+    SafeResolve(deferred, Napi::Boolean::New(Env(), true));
   }
 
   void OnError(const Napi::Error &e) override {
     Napi::HandleScope scope(Env());
-    deferred.Reject(e.Value());
+    SafeReject(deferred, e.Value());
   }
 };
 
@@ -195,4 +196,4 @@ Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
   }
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/windows/volume_metadata.cpp

@@ -154,6 +154,10 @@ private:
   VolumeMetadataOptions options_;
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       // Get drive status first
       DriveStatus status = CheckDriveStatus(mountPoint);
@@ -250,4 +254,4 @@ Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/windows/volume_mount_points.cpp

@@ -2,6 +2,7 @@
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
 #include "../common/error_utils.h"
+#include "../common/shutdown.h"
 #include "drive_status.h"
 #include "fs_meta.h"
 #include "security_utils.h"
@@ -21,7 +22,7 @@ struct DriveStringsBuffer {
       : buffer(std::make_unique<WCHAR[]>(size)) {}
 };
 
-class GetVolumeMountPointsWorker : public Napi::AsyncWorker {
+class GetVolumeMountPointsWorker : public SafeAsyncWorker {
 
 private:
   Napi::Promise::Deferred deferred_;
@@ -31,10 +32,14 @@ private:
 public:
   GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred,
                              uint32_t timeoutMs = 5000)
-      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred),
+      : SafeAsyncWorker(deferred.Env()), deferred_(deferred),
         timeoutMs_(timeoutMs) {}
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       DEBUG_LOG("[GetVolumeMountPoints] getting logical drive strings size");
       DWORD size = GetLogicalDriveStringsW(0, nullptr);
@@ -74,12 +79,19 @@ public:
       }
 
       // Check all drive statuses in parallel
+      if (IsShuttingDown()) {
+        return;
+      }
       auto statuses = CheckDriveStatus(paths, timeoutMs_);
 
       // Build mount points from results
       mountPoints_.reserve(paths.size());
 
       for (size_t i = 0; i < paths.size(); i++) {
+        if (IsShuttingDown()) {
+          return;
+        }
+
         MountPoint mp;
         mp.mountPoint = paths[i];
         mp.status = DriveStatusToString(statuses[i]);
@@ -115,6 +127,7 @@ public:
   }
 
   void OnOK() override {
+    Napi::HandleScope scope(Env());
     auto env = Env();
     Napi::Array result = Napi::Array::New(env, mountPoints_.size());
 
@@ -122,7 +135,12 @@ public:
       result[i] = mountPoints_[i].ToObject(env);
     }
 
-    deferred_.Resolve(result);
+    SafeResolve(deferred_, result);
+  }
+
+  void OnError(const Napi::Error &error) override {
+    Napi::HandleScope scope(Env());
+    SafeReject(deferred_, error.Value());
   }
 
 }; // class GetVolumeMountPointsWorker
@@ -140,4 +158,4 @@ Napi::Promise GetVolumeMountPoints(const Napi::CallbackInfo &info) {
   worker->Queue();
   return deferred.Promise();
 }
-} // namespace FSMeta
+} // namespace FSMeta