@photostructure/fs-metadata 0.3.2 → 0.4.0

package/dist/types/volume_metadata.d.ts

@@ -1,54 +1,8 @@
-import type { MountPoint } from "./mount_point.js";
-import { type Options } from "./options.js";
-import { type RemoteInfo } from "./remote_info.js";
 import type { GetVolumeMetadataOptions, NativeBindingsFn } from "./types/native_bindings.js";
-/**
- * Metadata associated to a volume.
- *
- * @see https://en.wikipedia.org/wiki/Volume_(computing)
- */
-export interface VolumeMetadata extends RemoteInfo, MountPoint {
-    /**
-     * The name of the partition
-     */
-    label?: string;
-    /**
-     * Total size in bytes
-     */
-    size?: number;
-    /**
-     * Used size in bytes
-     */
-    used?: number;
-    /**
-     * Available size in bytes
-     */
-    available?: number;
-    /**
-     * Path to the device or service that the mountpoint is from.
-     *
-     * Examples include `/dev/sda1`, `nfs-server:/export`,
-     * `//username@remoteHost/remoteShare`, or `//cifs-server/share`.
-     *
-     * May be undefined for remote volumes.
-     */
-    mountFrom?: string;
-    /**
-     * The name of the mount. This may match the resolved mountPoint.
-     */
-    mountName?: string;
-    /**
-     * UUID for the volume, like "c9b08f6e-b392-11ef-bf19-4b13bb7db4b4".
-     *
-     * On windows, this _may_ be the 128-bit volume UUID, but if that is not
-     * available, like in the case of remote volumes, we fallback to the 32-bit
-     * volume serial number, rendered in lowercase hexadecimal.
-     */
-    uuid?: string;
-}
-export declare function getVolumeMetadata(o: GetVolumeMetadataOptions & Options, nativeFn: NativeBindingsFn): Promise<VolumeMetadata>;
-export declare function getAllVolumeMetadata(opts: Required<Options> & {
+import type { Options } from "./types/options.js";
+import type { VolumeMetadata } from "./types/volume_metadata.js";
+export declare function getVolumeMetadataImpl(o: GetVolumeMetadataOptions & Options, nativeFn: NativeBindingsFn): Promise<VolumeMetadata>;
+export declare function getAllVolumeMetadataImpl(opts: Required<Options> & {
     includeSystemVolumes?: boolean;
     maxConcurrency?: number;
 }, nativeFn: NativeBindingsFn): Promise<VolumeMetadata[]>;
-export declare const _: undefined;

package/dist/types/volume_mount_points.d.ts

@@ -1,9 +1,6 @@
-import { MountPoint } from "./mount_point.js";
-import { Options } from "./options.js";
 import { SystemVolumeConfig } from "./system_volume.js";
+import type { MountPoint } from "./types/mount_point.js";
 import type { NativeBindingsFn } from "./types/native_bindings.js";
+import type { Options } from "./types/options.js";
 export type GetVolumeMountPointOptions = Partial<Pick<Options, "timeoutMs" | "linuxMountTablePaths" | "maxConcurrency" | "includeSystemVolumes"> & SystemVolumeConfig>;
-/**
- * Helper function for {@link getVolumeMountPoints}.
- */
-export declare function getVolumeMountPoints(opts: Required<GetVolumeMountPointOptions>, nativeFn: NativeBindingsFn): Promise<MountPoint[]>;
+export declare function getVolumeMountPointsImpl(opts: Required<GetVolumeMountPointOptions>, nativeFn: NativeBindingsFn): Promise<MountPoint[]>;

package/jest.config.base.cjs

@@ -0,0 +1,63 @@
+// @ts-check
+
+// jest.config.base.cjs
+
+const { argv, platform } = require("node:process");
+
+const otherPlatforms = ["linux", "darwin", "windows"]
+  .filter((ea) => ea !== (platform === "win32" ? "windows" : platform))
+  .map((ea) => `/${ea}/`);
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+const baseConfig = {
+  testEnvironment: "jest-environment-node",
+  roots: ["<rootDir>/src"],
+  coverageProvider: "v8",
+  moduleNameMapper: {
+    "^(\\.{1,2}/.*)\\.js$": "$1",
+  },
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+  verbose: true,
+  silent: false,
+  randomize: true,
+  setupFilesAfterEnv: [
+    "jest-extended/all",
+    "<rootDir>/src/test-utils/jest-matchers.ts",
+  ],
+  collectCoverage: !argv.includes("--no-coverage"),
+  coverageDirectory: "coverage",
+  coverageReporters: ["text", "lcov", "html"],
+  collectCoverageFrom: [
+    "src/**/*.ts",
+    // We have to include dist/*js because there are integration tests that
+    // import/require the root package directory:
+    "dist/*js",
+  ],
+  coveragePathIgnorePatterns: [
+    "exports",
+    "setup",
+    "/test-utils/",
+    "\.d.ts$",
+    "/types/",
+    ...otherPlatforms,
+  ],
+  coverageThreshold: {
+    // As of 20250106 on linux:
+    // % Stmts | % Branch | % Funcs | % Lines
+    //   93.63 |    87.05 |   91.86 |   93.63
+    // As of 20250106 on darwin:
+    // % Stmts | % Branch | % Funcs | % Lines
+    //   85.91 |    84.03 |   88.69 |   85.91
+    // As of 20250106 on windows:
+    // % Stmts | % Branch | % Funcs | % Lines
+    //   85.91 |    84.03 |   88.69 |   85.91
+    global: {
+      statements: 80,
+      branches: 80,
+      functions: 80,
+      lines: 80,
+    },
+  },
+};
+
+module.exports = baseConfig;

package/jest.config.cjs

@@ -1,15 +1,11 @@
 // @ts-check
 
-/** @type {import('ts-jest').JestConfigWithTsJest} */
+const baseConfig = require("./jest.config.base.cjs");
 
+/** @type {import('ts-jest').JestConfigWithTsJest} */
 const config = {
+  ...baseConfig,
   displayName: "@photostructure/fs-metadata (CJS)",
-  testEnvironment: "jest-environment-node",
-  roots: ["<rootDir>/src"],
-  coverageProvider: "v8",
-  moduleNameMapper: {
-    "^(\\.{1,2}/.*)\\.js$": "$1",
-  },
   transform: {
     "^.+\\.(c)?ts$": [
       "ts-jest",
@@ -19,15 +15,6 @@ const config = {
       },
     ],
   },
-  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
-  collectCoverage: false,
-  verbose: true,
-  silent: false,
-  randomize: true,
-  setupFilesAfterEnv: [
-    "jest-extended/all",
-    "<rootDir>/src/test-utils/jest-matchers.ts",
-  ],
 };
 
 module.exports = config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@photostructure/fs-metadata",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Cross-platform native filesystem metadata retrieval for Node.js",
   "homepage": "https://photostructure.github.io/fs-metadata/",
   "types": "./dist/types/index.d.ts",
@@ -21,23 +21,20 @@
     "configure": "node scripts/configure.mjs",
     "prebuildify": "prebuildify --napi --tag-libc --strip",
     "prebuild": "run-s configure prebuildify",
+    "// clang-tidy": "on ubuntu: `sudo apt install clang-tidy`, on mac: `brew install llvm && alias clang-tidy=$(brew --prefix llvm)/bin/clang-tidy`. Note that there will be warnings for non-platform-relevant files.",
     "clang-tidy": "node-gyp configure -- -f compile_commands_json && clang-tidy -p build/Release src/**/*.cpp",
     "compile": "run-p compile:*",
     "compile:esm": "tsc -p tsconfig.esm.json --noEmit",
     "compile:cjs": "tsc -p tsconfig.cjs.json --noEmit",
     "compile:types": "tsc -p tsconfig.types.json",
-    "postcompile:types": "mv dist/types/index.d.mts dist/types/index.d.ts",
-    "watch": "tsc --watch",
     "bundle": "run-p bundle:* compile:types",
-    "bundle:cjs": "tsup src/index.cts --format cjs --tsconfig tsconfig.cjs.json",
-    "bundle:esm": "tsup src/index.mts --format esm --tsconfig tsconfig.esm.json",
-    "docs": "typedoc --tsconfig tsconfig.esm.json --out docs src/index.mts",
-    "jest:coverage": "jest --coverage",
-    "jest:watch": "npm t -- --watch",
-    "jest:clear": "jest --clearCache",
+    "bundle:cjs": "tsup src/index.ts --format cjs --tsconfig tsconfig.cjs.json",
+    "bundle:esm": "tsup src/index.ts --format esm --tsconfig tsconfig.esm.json",
+    "docs": "typedoc --tsconfig tsconfig.esm.json --out docs src/index.ts",
     "// tests": "`compile` validates the typescript compiles with tsc. `lint` checks for style issues. `bundle` uses tsup to emit the CJS and ESM rollups that the integration tests depend on. `test:*` runs the tests.",
+    "// test": "support `npm t name_of_file` (and don't fail due to missing coverage)",
+    "test": "npm run test:cjs -- --no-coverage",
     "tests": "run-s compile lint bundle test:*",
-    "test": "npm run test:cjs",
     "test:cjs": "jest --config jest.config.cjs",
     "test:esm": "node --experimental-vm-modules --no-warnings node_modules/jest/bin/jest.js --config jest.config.mjs",
     "// test:memory:todo": "set up valgrind or similar",
@@ -52,7 +49,7 @@
     "fmt:json": "prettier --write \"**/*.json\"",
     "fmt:pkg": "npm pkg fix",
     "fmt:ts": "prettier --write \"**/*.(c|m)?ts\"",
-    "precommit": "run-s fmt clean prebuild tests snyk",
+    "precommit": "run-s fmt clean prebuild tests",
     "prepare-release": "npm run bundle",
     "release": "release-it"
   },
@@ -89,9 +86,9 @@
   "devDependencies": {
     "@eslint/js": "^9.17.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.10.3",
-    "@typescript-eslint/eslint-plugin": "^8.19.0",
-    "@typescript-eslint/parser": "^8.19.0",
+    "@types/node": "^22.10.5",
+    "@typescript-eslint/eslint-plugin": "^8.19.1",
+    "@typescript-eslint/parser": "^8.19.1",
     "cross-env": "^7.0.3",
     "del-cli": "^6.0.0",
     "eslint": "^9.17.0",
@@ -110,8 +107,9 @@
     "terser": "^5.37.0",
     "ts-jest": "^29.2.5",
     "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
     "typedoc": "^0.27.6",
     "typescript": "^5.7.2",
-    "typescript-eslint": "^8.19.0"
+    "typescript-eslint": "^8.19.1"
   }
 }

package/src/async.ts

@@ -2,6 +2,7 @@ import { availableParallelism } from "node:os";
 import { env } from "node:process";
 import { gt0, isNumber } from "./number.js";
 import { isBlank } from "./string.js";
+import { DayMs } from "./units.js";
 
 /**
  * An error that is thrown when a promise does not resolve within the specified
@@ -53,6 +54,14 @@ export async function withTimeout<T>(opts: {
     );
   }
 
+  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;
   }

package/src/darwin/hidden.cpp

@@ -15,6 +15,13 @@ GetHiddenWorker::GetHiddenWorker(std::string path,
 
 void GetHiddenWorker::Execute() {
   DEBUG_LOG("[GetHiddenWorker] checking hidden status for: %s", path_.c_str());
+
+  // Add path validation to prevent directory traversal
+  if (path_.find("..") != std::string::npos) {
+    SetError("Invalid path containing '..'");
+    return;
+  }
+
   struct stat statbuf;
   if (stat(path_.c_str(), &statbuf) != 0) {
     int error = errno;
@@ -73,6 +80,13 @@ SetHiddenWorker::SetHiddenWorker(std::string path, bool hidden,
 void SetHiddenWorker::Execute() {
   DEBUG_LOG("[SetHiddenWorker] setting hidden=%d for: %s", hidden_,
             path_.c_str());
+
+  // Add path validation to prevent directory traversal
+  if (path_.find("..") != std::string::npos) {
+    SetError("Invalid path containing '..'");
+    return;
+  }
+
   struct stat statbuf;
   if (stat(path_.c_str(), &statbuf) != 0) {
     int error = errno;

package/src/darwin/raii_utils.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <sys/mount.h>
+
+namespace FSMeta {
+
+// Generic RAII wrapper for resources that need free()
+template <typename T> class ResourceRAII {
+private:
+  T *resource_;
+
+public:
+  ResourceRAII() : resource_(nullptr) {}
+  ~ResourceRAII() {
+    if (resource_) {
+      free(resource_);
+    }
+  }
+
+  T **ptr() { return &resource_; }
+  T *get() { return resource_; }
+
+  // Add move operations for better resource management
+  ResourceRAII(ResourceRAII &&other) noexcept : resource_(other.resource_) {
+    other.resource_ = nullptr;
+  }
+
+  ResourceRAII &operator=(ResourceRAII &&other) noexcept {
+    if (this != &other) {
+      if (resource_)
+        free(resource_);
+      resource_ = other.resource_;
+      other.resource_ = nullptr;
+    }
+    return *this;
+  }
+
+  // Prevent copying
+  ResourceRAII(const ResourceRAII &) = delete;
+  ResourceRAII &operator=(const ResourceRAII &) = delete;
+};
+
+// Specialized for mount info
+using MountBufferRAII = ResourceRAII<struct statfs>;
+
+// CoreFoundation RAII wrapper
+template <typename T> class CFReleaser {
+private:
+  T ref_;
+
+public:
+  explicit CFReleaser(T ref = nullptr) noexcept : ref_(ref) {}
+  ~CFReleaser() { reset(); }
+
+  void reset(T ref = nullptr) {
+    if (ref_) {
+      CFRelease(ref_);
+    }
+    ref_ = ref;
+  }
+
+  operator T() const noexcept { return ref_; }
+  T get() const noexcept { return ref_; }
+  bool isValid() const noexcept { return ref_ != nullptr; }
+
+  // Prevent copying
+  CFReleaser(const CFReleaser &) = delete;
+  CFReleaser &operator=(const CFReleaser &) = delete;
+
+  // Allow moving
+  CFReleaser(CFReleaser &&other) noexcept : ref_(other.ref_) {
+    other.ref_ = nullptr;
+  }
+  CFReleaser &operator=(CFReleaser &&other) noexcept {
+    if (this != &other) {
+      reset();
+      ref_ = other.ref_;
+      other.ref_ = nullptr;
+    }
+    return *this;
+  }
+};
+
+} // namespace FSMeta

package/src/darwin/volume_metadata.cpp

@@ -2,6 +2,7 @@
 
 #include "../common/debug_log.h"
 #include "./fs_meta.h"
+#include "./raii_utils.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <DiskArbitration/DiskArbitration.h>
@@ -36,55 +37,6 @@ static std::string CFStringToString(CFStringRef cfString) {
   return result;
 }
 
-// Improved CFReleaser with proper Core Foundation support
-template <typename T> class CFReleaser {
-private:
-  T ref_;
-
-public:
-  explicit CFReleaser(T ref = nullptr) noexcept : ref_(ref) {}
-
-  // Delete copy operations
-  CFReleaser(const CFReleaser &) = delete;
-  CFReleaser &operator=(const CFReleaser &) = delete;
-
-  // Move operations
-  CFReleaser(CFReleaser &&other) noexcept : ref_(other.ref_) {
-    other.ref_ = nullptr;
-  }
-
-  CFReleaser &operator=(CFReleaser &&other) noexcept {
-    if (this != &other) {
-      reset();
-      ref_ = other.ref_;
-      other.ref_ = nullptr;
-    }
-    return *this;
-  }
-
-  ~CFReleaser() { reset(); }
-
-  void reset(T ref = nullptr) {
-    if (ref_) {
-      CFRelease(ref_);
-    }
-    ref_ = ref;
-  }
-
-  // Implicit conversion operator for Core Foundation APIs
-  operator T() const noexcept { return ref_; }
-
-  T get() const noexcept { return ref_; }
-  bool isValid() const noexcept { return ref_ != nullptr; }
-
-  // Release ownership
-  T release() noexcept {
-    T temp = ref_;
-    ref_ = nullptr;
-    return temp;
-  }
-};
-
 class GetVolumeMetadataWorker : public MetadataWorkerBase {
 public:
   GetVolumeMetadataWorker(const std::string &mountPoint,
@@ -178,12 +130,12 @@ private:
     // Check if this is a network filesystem
     if (metadata.fstype == "smbfs" || metadata.fstype == "nfs" ||
         metadata.fstype == "afpfs" || metadata.fstype == "webdav") {
-      // For network filesystems, we consider them healthy even without DA info
       metadata.remote = true;
       metadata.status = "healthy";
       return;
     }
 
+    // Create session on current thread
     CFReleaser<DASessionRef> session(DASessionCreate(kCFAllocatorDefault));
     if (!session.isValid()) {
       DEBUG_LOG("[GetVolumeMetadataWorker] Failed to create DA session");
@@ -193,21 +145,39 @@ private:
     }
 
     try {
-      // RAII cleanup for RunLoop scheduling
+      // Get thread-local runloop or create new one if needed
+      CFRunLoopRef runLoop = CFRunLoopGetCurrent();
+      if (!runLoop) {
+        // If no runloop exists, create a new one for this thread
+        CFRunLoopRun();
+        runLoop = CFRunLoopGetCurrent();
+        if (!runLoop) {
+          throw std::runtime_error("Failed to create thread-local runloop");
+        }
+      }
+
+      // Schedule session with our runloop
+      DASessionScheduleWithRunLoop(session.get(), runLoop,
+                                   kCFRunLoopDefaultMode);
+
+      // Use RAII to ensure cleanup
       struct RunLoopCleaner {
         DASessionRef session;
-        explicit RunLoopCleaner(DASessionRef s) : session(s) {}
+        CFRunLoopRef runLoop;
+        bool shouldStop;
+        RunLoopCleaner(DASessionRef s, CFRunLoopRef l, bool stop = false)
+            : session(s), runLoop(l), shouldStop(stop) {}
         ~RunLoopCleaner() {
-          DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(),
+          DASessionUnscheduleFromRunLoop(session, runLoop,
                                          kCFRunLoopDefaultMode);
+          if (shouldStop) {
+            CFRunLoopStop(runLoop);
+          }
         }
-      };
+      } scopeGuard(session.get(), runLoop, !CFRunLoopGetCurrent());
 
-      // Schedule session with RunLoop
-      DASessionScheduleWithRunLoop(session.get(), CFRunLoopGetCurrent(),
-                                   kCFRunLoopDefaultMode);
-
-      auto scopeGuard = std::make_unique<RunLoopCleaner>(session.get());
+      // Run the run loop briefly to ensure DA is ready
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, true);
 
       CFReleaser<DADiskRef> disk(DADiskCreateFromBSDName(
           kCFAllocatorDefault, session.get(), metadata.mountFrom.c_str()));
@@ -228,12 +198,17 @@ private:
         return;
       }
 
+      // Ensure we have a complete description before continuing
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
+
+      // Process description synchronously since we're already on the right
+      // thread
       ProcessDiskDescription(description.get());
 
-      // Only set ready if we got this far without errors
       if (metadata.status != "partial") {
         metadata.status = "healthy";
       }
+
     } catch (const std::exception &e) {
       DEBUG_LOG("[GetVolumeMetadataWorker] Exception: %s", e.what());
       metadata.status = "error";

package/src/darwin/volume_mount_points.cpp

@@ -1,7 +1,8 @@
 // src/darwin/volume_mount_points.cpp
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
-#include "fs_meta.h"
+#include "./fs_meta.h"
+#include "./raii_utils.h"
 #include <chrono>
 #include <future>
 #include <sys/mount.h>
@@ -24,9 +25,12 @@ public:
   void Execute() override {
     DEBUG_LOG("[GetVolumeMountPointsWorker] Executing");
     try {
-      // Get mount list - this is fast
-      struct statfs *mntbufp;
-      int count = getmntinfo(&mntbufp, MNT_WAIT);
+      MountBufferRAII mntbuf;
+      // Use MNT_NOWAIT for better performance - we'll verify accessibility
+      // separately and our error handling already covers mount state changes
+      // See https://github.com/swiftlang/swift-corelibs-foundation/issues/4649
+
+      int count = getmntinfo_r_np(mntbuf.ptr(), MNT_NOWAIT);
 
       if (count <= 0) {
         throw std::runtime_error("Failed to get mount information");
@@ -34,36 +38,39 @@ public:
 
       for (int i = 0; i < count; i++) {
         MountPoint mp;
-        mp.mountPoint = mntbufp[i].f_mntonname;
-        mp.fstype = mntbufp[i].f_fstypename;
+        mp.mountPoint = mntbuf.get()[i].f_mntonname;
+        mp.fstype = mntbuf.get()[i].f_fstypename;
         mp.error = ""; // Initialize error field
 
         DEBUG_LOG("[GetVolumeMountPointsWorker] Checking mount point: %s",
                   mp.mountPoint.c_str());
 
         try {
-          // Use shared_future to allow multiple gets
-          std::shared_future<bool> future =
+          // Use RAII to manage future
+          auto future = std::make_shared<std::future<bool>>(
               std::async(std::launch::async, [path = mp.mountPoint]() {
-                return access(path.c_str(), R_OK) == 0;
-              }).share();
+                // Use faccessat for better security
+                return faccessat(AT_FDCWD, path.c_str(), R_OK, AT_EACCESS) == 0;
+              }));
 
-          auto status = future.wait_for(std::chrono::milliseconds(timeoutMs_));
+          auto status = future->wait_for(std::chrono::milliseconds(timeoutMs_));
 
-          if (status == std::future_status::timeout) {
+          switch (status) {
+          case std::future_status::timeout:
             mp.status = "disconnected";
             mp.error = "Access check timed out";
-            DEBUG_LOG(
-                "[GetVolumeMountPointsWorker] Access check timed out for: %s",
-                mp.mountPoint.c_str());
-          } else if (status == std::future_status::ready) {
+            DEBUG_LOG("[GetVolumeMountPointsWorker] Access check timed out: %s",
+                      mp.mountPoint.c_str());
+            break;
+
+          case std::future_status::ready:
             try {
-              bool isAccessible = future.get();
+              bool isAccessible = future->get();
               mp.status = isAccessible ? "healthy" : "inaccessible";
               if (!isAccessible) {
                 mp.error = "Path is not accessible";
               }
-              DEBUG_LOG("[GetVolumeMountPointsWorker] Access check %s for: %s",
+              DEBUG_LOG("[GetVolumeMountPointsWorker] Access check %s: %s",
                         isAccessible ? "succeeded" : "failed",
                         mp.mountPoint.c_str());
             } catch (const std::exception &e) {
@@ -71,12 +78,14 @@ public:
               mp.error = std::string("Access check failed: ") + e.what();
               DEBUG_LOG("[GetVolumeMountPointsWorker] Exception: %s", e.what());
             }
-          } else {
+            break;
+
+          default:
             mp.status = "error";
             mp.error = "Unexpected future status";
-            DEBUG_LOG(
-                "[GetVolumeMountPointsWorker] Unexpected future status for: %s",
-                mp.mountPoint.c_str());
+            DEBUG_LOG("[GetVolumeMountPointsWorker] Unexpected status: %s",
+                      mp.mountPoint.c_str());
+            break;
           }
         } catch (const std::exception &e) {
           mp.status = "error";

package/src/debuglog.ts

@@ -1,7 +1,11 @@
 import { debuglog, format } from "node:util";
-import { defer } from "./defer.js";
 
-// allow tests to reset the debug log context
+// inlined as a hack to get around relative imports broken in ts-node (used by
+// the debuglog tests):
+function defer<T>(thunk: () => T) {
+  let t: T;
+  return () => (t ??= thunk());
+}
 
 export const debugLogContext = defer(() => {
   for (const ea of ["fs-metadata", "fs-meta"]) {

package/src/defer.ts

@@ -1,6 +1,6 @@
 // src/defer.ts
 
-type Defer<T> = (() => T) & {
+export type Defer<T> = (() => T) & {
   reset: () => void;
 };
 

package/src/dirname.ts

@@ -0,0 +1,13 @@
+import { getCallerDirname } from "./stack_path";
+
+// Thanks to tsup shims, __dirname should always be defined except when run by
+// jest (which will use the stack_path shim)
+export function _dirname() {
+  try {
+    if (typeof __dirname !== "undefined") return __dirname;
+  } catch {
+    // ignore
+  }
+  // we must be in jest. Use the stack_path ~~hack~~ shim:
+  return getCallerDirname();
+}

package/src/global.d.ts

@@ -0,0 +1 @@
+/// <reference types="jest-extended" />