@photostructure/fs-metadata 0.5.0 → 0.5.1

package/scripts/sanitizers-test.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+# AddressSanitizer and LeakSanitizer test runner for @photostructure/fs-metadata
+# Runs comprehensive memory safety checks on native code
+
+set -euo pipefail
+
+# Check if we're on Linux
+if [[ "$OSTYPE" != "linux-gnu"* ]]; then
+    echo "AddressSanitizer tests are only supported on Linux"
+    exit 0
+fi
+
+# Check for clang
+if ! command -v clang &> /dev/null; then
+    echo "Error: clang is required for AddressSanitizer tests"
+    echo "Install with: sudo apt-get install clang"
+    exit 1
+fi
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+CLEAN_BUILD=${CLEAN_BUILD:-1}
+VERBOSE=${VERBOSE:-0}
+OUTPUT_FILE="asan-output.log"
+
+echo -e "${YELLOW}Running AddressSanitizer and LeakSanitizer tests...${NC}"
+
+# Clean previous builds if requested
+if [[ "$CLEAN_BUILD" == "1" ]]; then
+    echo "Cleaning previous builds..."
+    rm -rf build/
+fi
+rm -f "$OUTPUT_FILE"
+
+# Set up build environment
+export CC=clang
+export CXX=clang++
+export CFLAGS="-fsanitize=address -fno-omit-frame-pointer -g -O1"
+export CXXFLAGS="-fsanitize=address -fno-omit-frame-pointer -g -O1"
+export LDFLAGS="-fsanitize=address"
+
+# Comprehensive ASAN options combining both implementations
+export ASAN_OPTIONS="detect_leaks=1:halt_on_error=0:print_stats=1:check_initialization_order=1:strict_init_order=1:print_module_map=1"
+export LSAN_OPTIONS="suppressions=$(pwd)/.lsan-suppressions.txt:print_suppressions=0"
+
+# Increase Node.js heap size for ASan overhead
+export NODE_OPTIONS="--max-old-space-size=8192"
+
+# Find and set ASan runtime library
+echo "Detecting ASan runtime library..."
+ASAN_LIB=$(clang -print-file-name=libclang_rt.asan-x86_64.so 2>/dev/null || echo "")
+
+if [[ -n "$ASAN_LIB" && "$ASAN_LIB" != *"not found"* && -f "$ASAN_LIB" ]]; then
+    export LD_PRELOAD="$ASAN_LIB"
+    echo -e "${BLUE}Using ASan library: $ASAN_LIB${NC}"
+else
+    # Try common paths as fallback
+    for lib in /usr/lib/x86_64-linux-gnu/libasan.so.{8,6} /usr/lib64/libasan.so.{8,6}; do
+        if [[ -f "$lib" ]]; then
+            export LD_PRELOAD="$lib"
+            echo -e "${BLUE}Using ASan library: $lib${NC}"
+            break
+        fi
+    done
+fi
+
+if [[ -z "${LD_PRELOAD:-}" ]]; then
+    echo -e "${YELLOW}Warning: Could not find ASan runtime library${NC}"
+fi
+
+# Build the native module
+echo "Building with AddressSanitizer..."
+npm run setup:native
+npm run clean:native
+node-gyp configure build
+
+# Run tests and capture output
+echo -e "${YELLOW}Running tests with AddressSanitizer...${NC}"
+set +e  # Don't exit on test failure
+npm test -- --no-coverage 2>&1 | tee "$OUTPUT_FILE"
+TEST_EXIT_CODE=${PIPESTATUS[0]}
+set -e
+
+echo -e "${BLUE}\nFull ASAN output saved to: $OUTPUT_FILE${NC}"
+
+# Analyze output for errors specific to our code
+echo -e "\n${YELLOW}Analyzing ASAN output...${NC}"
+
+# Count different types of issues
+OUR_ERRORS=0
+OUR_LEAKS=0
+INTERNAL_LEAKS=0
+
+# Check for ASAN errors in our code (not V8/Node internals)
+if grep -E "(ERROR: AddressSanitizer|ERROR: LeakSanitizer)" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/)" > /dev/null; then
+    OUR_ERRORS=1
+fi
+
+# Check for direct/indirect leaks in our code with context
+while IFS= read -r line_num; do
+    # Get 5 lines before and 10 lines after for context
+    start=$((line_num - 5))
+    end=$((line_num + 10))
+    if sed -n "${start},${end}p" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/|photostructure)" > /dev/null; then
+        OUR_LEAKS=1
+        break
+    fi
+done < <(grep -n "Direct leak\|Indirect leak" "$OUTPUT_FILE" | cut -d: -f1)
+
+# Count V8/Node internal leaks for information
+INTERNAL_LEAKS=$(grep -c "leak.*\/usr\/bin\/node" "$OUTPUT_FILE" 2>/dev/null || echo "0")
+INTERNAL_LEAKS="${INTERNAL_LEAKS//[[:space:]]/}"  # Remove any whitespace
+
+# Report results
+EXIT_CODE=0
+
+if [[ "$OUR_ERRORS" -eq 1 ]]; then
+    echo -e "${RED}\n✗ AddressSanitizer found errors in fs-metadata code:${NC}"
+    grep -E "(ERROR: AddressSanitizer|ERROR: LeakSanitizer)" "$OUTPUT_FILE" | grep -E "(fs_metadata\.node|/src/)" | head -20
+    EXIT_CODE=1
+fi
+
+if [[ "$OUR_LEAKS" -eq 1 ]]; then
+    echo -e "${RED}\n✗ LeakSanitizer found memory leaks in fs-metadata code:${NC}"
+    # Show leak summary
+    grep -A 5 "SUMMARY: AddressSanitizer" "$OUTPUT_FILE" || true
+    EXIT_CODE=1
+fi
+
+if [[ "$EXIT_CODE" -eq 0 ]]; then
+    echo -e "${GREEN}\n✓ AddressSanitizer and LeakSanitizer tests passed (no issues in fs-metadata code)${NC}"
+    if [[ "$INTERNAL_LEAKS" -gt 0 ]]; then
+        echo -e "${YELLOW}   Note: $INTERNAL_LEAKS V8/Node.js internal leaks detected (suppressed)${NC}"
+    fi
+else
+    echo -e "${RED}\n✗ Memory safety issues detected!${NC}"
+    echo -e "${YELLOW}See $OUTPUT_FILE for full details${NC}"
+fi
+
+# Show ASAN statistics if verbose
+if [[ "$VERBOSE" -eq 1 ]] && grep -q "Stats:" "$OUTPUT_FILE"; then
+    echo -e "\n${BLUE}ASAN Statistics:${NC}"
+    grep -A 20 "Stats:" "$OUTPUT_FILE" | head -20
+fi
+
+# Clean build artifacts to ensure no ASAN-compiled code remains
+echo -e "\n${YELLOW}Cleaning build artifacts...${NC}"
+npm run clean:native > /dev/null 2>&1
+echo -e "${GREEN}✓ Build artifacts cleaned${NC}"
+
+exit $EXIT_CODE

package/scripts/{configure.mjs → setup-native.mjs}

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
-// scripts/configure.mjs
+// scripts/setup-native.mjs
+
+// This script sets up the config.gypi file to include GIO support when available.
+// It should be run before building native modules with node-gyp.
 
 import { execSync } from "node:child_process";
 import { writeFileSync } from "node:fs";

package/scripts/valgrind-test.mjs

@@ -15,7 +15,7 @@ import {
   getVolumeMetadata,
   getVolumeMountPoints,
   isHidden,
-} from "../dist/index.js";
+} from "../dist/index.mjs";
 
 async function runTests() {
   console.log("Starting valgrind memory leak tests...");

package/scripts/{valgrind.sh → valgrind-test.sh}

@@ -35,6 +35,21 @@ if [ ! -f "$VALGRIND_TEST" ]; then
     exit 1
 fi
 
+# Check if dist directory exists (indicates build completed)
+if [ ! -d "$ROOT_DIR/dist" ]; then
+    echo -e "${RED}Error: dist/ directory not found. Run 'npm run build:dist' first.${NC}"
+    exit 1
+fi
+
+# Pre-flight check: run the test script without valgrind first
+echo "Running pre-flight check..."
+if ! node "$VALGRIND_TEST" > /dev/null 2>&1; then
+    echo -e "${RED}Error: Test script failed to run. Running again to show error:${NC}"
+    node "$VALGRIND_TEST"
+    exit 1
+fi
+echo -e "${GREEN}✓ Pre-flight check passed${NC}"
+
 # Use the committed suppressions file
 SUPP_FILE="$ROOT_DIR/.valgrind.supp"
 

package/src/binding.cpp

@@ -93,6 +93,6 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   return exports;
 }
 
-NODE_API_MODULE(node_fs_meta, Init)
+NODE_API_MODULE(fs_metadata, Init)
 
 } // namespace

package/src/common/error_utils.h

@@ -1,5 +1,6 @@
 // src/common/error_utils.h
 #pragma once
+#include <cstring>
 #include <stdexcept>
 #include <string>
 
@@ -11,9 +12,25 @@ public:
       : std::runtime_error(message) {}
 };
 
+// Simple error code only version
 inline std::string CreateErrorMessage(const char *operation, int error) {
   return std::string(operation) +
          " failed with error: " + std::to_string(error);
 }
 
+// Convenience function for common pattern: "operation failed for 'path': error"
+inline std::string CreatePathErrorMessage(const char *operation,
+                                          const std::string &path, int error) {
+  return std::string(operation) + " failed for '" + path +
+         "': " + std::string(strerror(error)) + " (" + std::to_string(error) +
+         ")";
+}
+
+// For operations without a path context
+inline std::string CreateDetailedErrorMessage(const char *operation,
+                                              int error) {
+  return std::string(operation) + " failed: " + std::string(strerror(error)) +
+         " (" + std::to_string(error) + ")";
+}
+
 } // namespace FSMeta

package/src/common/metadata_worker.h

@@ -20,7 +20,10 @@ protected:
     deferred_.Reject(error.Value());
   }
 
-  void OnOK() override { deferred_.Resolve(metadata.ToObject(Env())); }
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    deferred_.Resolve(metadata.ToObject(Env()));
+  }
 }; // class MetadataWorkerBase
 
 } // namespace FSMeta

package/src/darwin/hidden.cpp

@@ -1,6 +1,7 @@
 // src/darwin/hidden.cpp
 #include "hidden.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include <sys/stat.h>
 #include <unistd.h>
 
@@ -27,11 +28,11 @@ void GetHiddenWorker::Execute() {
     int error = errno;
     if (error == ENOENT) {
       DEBUG_LOG("[GetHiddenWorker] path not found: %s", path_.c_str());
-      SetError("Path not found");
+      SetError("Path not found: '" + path_ + "'");
     } else {
       DEBUG_LOG("[GetHiddenWorker] failed to stat path %s: %s (%d)",
                 path_.c_str(), strerror(error), error);
-      SetError(std::string("Failed to stat path: ") + strerror(error));
+      SetError(CreatePathErrorMessage("stat", path_, error));
     }
     return;
   }
@@ -41,11 +42,13 @@ void GetHiddenWorker::Execute() {
 }
 
 void GetHiddenWorker::OnOK() {
+  Napi::HandleScope scope(Env());
   auto env = Env();
   deferred_.Resolve(Napi::Boolean::New(env, is_hidden_));
 }
 
 void GetHiddenWorker::OnError(const Napi::Error &error) {
+  Napi::HandleScope scope(Env());
   deferred_.Reject(error.Value());
 }
 
@@ -92,11 +95,11 @@ void SetHiddenWorker::Execute() {
     int error = errno;
     if (error == ENOENT) {
       DEBUG_LOG("[SetHiddenWorker] path not found: %s", path_.c_str());
-      SetError("Path not found");
+      SetError("Path not found: '" + path_ + "'");
     } else {
       DEBUG_LOG("[SetHiddenWorker] failed to stat path %s: %s (%d)",
                 path_.c_str(), strerror(error), error);
-      SetError(std::string("Failed to stat path: ") + strerror(error));
+      SetError(CreatePathErrorMessage("stat", path_, error));
     }
     return;
   }
@@ -109,8 +112,10 @@ void SetHiddenWorker::Execute() {
   }
 
   if (chflags(path_.c_str(), new_flags) != 0) {
-    DEBUG_LOG("[SetHiddenWorker] failed to set flags for: %s", path_.c_str());
-    SetError("Failed to set flags");
+    int error = errno;
+    DEBUG_LOG("[SetHiddenWorker] failed to set flags for %s: %s (%d)",
+              path_.c_str(), strerror(error), error);
+    SetError(CreatePathErrorMessage("chflags", path_, error));
     return;
   }
   DEBUG_LOG("[SetHiddenWorker] successfully set hidden=%d for: %s", hidden_,
@@ -118,11 +123,13 @@ void SetHiddenWorker::Execute() {
 }
 
 void SetHiddenWorker::OnOK() {
+  Napi::HandleScope scope(Env());
   auto env = Env();
   deferred_.Resolve(env.Undefined());
 }
 
 void SetHiddenWorker::OnError(const Napi::Error &error) {
+  Napi::HandleScope scope(Env());
   deferred_.Reject(error.Value());
 }
 

package/src/darwin/volume_metadata.cpp

@@ -70,14 +70,14 @@ private:
     if (statvfs(mountPoint.c_str(), &vfs) != 0) {
       DEBUG_LOG("[GetVolumeMetadataWorker] statvfs failed: %s (%d)",
                 strerror(errno), errno);
-      SetError(CreateErrorMessage("statvfs", errno));
+      SetError(CreatePathErrorMessage("statvfs", mountPoint, errno));
       return false;
     }
 
     if (statfs(mountPoint.c_str(), &fs) != 0) {
       DEBUG_LOG("[GetVolumeMetadataWorker] statfs failed: %s (%d)",
                 strerror(errno), errno);
-      SetError(CreateErrorMessage("statfs", errno));
+      SetError(CreatePathErrorMessage("statfs", mountPoint, errno));
       return false;
     }
 

package/src/darwin/volume_mount_points.cpp

@@ -1,6 +1,7 @@
 // src/darwin/volume_mount_points.cpp
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include "./fs_meta.h"
 #include "./raii_utils.h"
 #include <chrono>
@@ -33,7 +34,13 @@ public:
       int count = getmntinfo_r_np(mntbuf.ptr(), MNT_NOWAIT);
 
       if (count <= 0) {
-        throw std::runtime_error("Failed to get mount information");
+        if (count == 0) {
+          throw std::runtime_error("No mount points found");
+        } else {
+          // getmntinfo_r_np returns -1 on error and sets errno
+          throw FSException(
+              CreateDetailedErrorMessage("getmntinfo_r_np", errno));
+        }
       }
 
       for (int i = 0; i < count; i++) {

package/src/linux/blkid_cache.cpp

@@ -2,6 +2,7 @@
 
 #include "blkid_cache.h"
 #include "../common/debug_log.h"
+#include "../common/error_utils.h"
 #include <stdexcept>
 
 namespace FSMeta {
@@ -14,8 +15,13 @@ BlkidCache::BlkidCache() : cache_(nullptr) {
   const std::lock_guard<std::mutex> lock(mutex_);
   DEBUG_LOG("[BlkidCache] initializing cache");
   if (blkid_get_cache(&cache_, nullptr) != 0) {
-    DEBUG_LOG("[BlkidCache] failed to initialize cache");
-    throw std::runtime_error("Failed to initialize blkid cache");
+    int error = errno;
+    DEBUG_LOG("[BlkidCache] failed to initialize cache: errno=%d", error);
+    if (error != 0) {
+      throw FSException(CreateDetailedErrorMessage("blkid_get_cache", error));
+    } else {
+      throw FSException("Failed to initialize blkid cache (no errno set)");
+    }
   }
   DEBUG_LOG("[BlkidCache] cache initialized successfully");
 }

package/src/linux/volume_metadata.cpp

@@ -31,7 +31,7 @@ public:
                 mountPoint.c_str());
       struct statvfs vfs;
       if (statvfs(mountPoint.c_str(), &vfs) != 0) {
-        throw FSException(CreateErrorMessage("statvfs", errno));
+        throw FSException(CreatePathErrorMessage("statvfs", mountPoint, errno));
       }
 
       const uint64_t blockSize = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;

package/src/platform.ts

@@ -1,5 +1,6 @@
 // src/platform.ts
 
+import { existsSync, readFileSync } from "node:fs";
 import { arch, platform } from "node:process";
 
 export const isLinux = platform === "linux";
@@ -7,3 +8,27 @@ export const isWindows = platform === "win32";
 export const isMacOS = platform === "darwin";
 
 export const isArm = isLinux && arch.startsWith("arm");
+export const isARM64 = arch === "arm64";
+
+/**
+ * Detects if we're running on Alpine Linux by checking /etc/os-release
+ */
+export function isAlpine(): boolean {
+  if (!isLinux) return false;
+
+  try {
+    const osRelease = readFileSync("/etc/os-release", "utf8");
+    return (
+      osRelease.includes("Alpine Linux") || osRelease.includes("ID=alpine")
+    );
+  } catch {
+    return existsSync("/etc/alpine-release");
+  }
+}
+
+/**
+ * Detects if we're likely running under emulation (as of 202506 there aren't free GHA ARM64 runners)
+ */
+export function isEmulated(): boolean {
+  return isLinux && isARM64;
+}

package/src/test-utils/benchmark-harness.ts

@@ -0,0 +1,192 @@
+import { getTimingMultiplier } from "./test-timeout-config";
+
+export interface BenchmarkOptions {
+  /**
+   * Target duration for the benchmark in milliseconds (default: 20000ms / 20 seconds)
+   */
+  targetDurationMs?: number;
+
+  /**
+   * Maximum timeout for the entire benchmark in milliseconds (default: 60000ms / 1 minute)
+   */
+  maxTimeoutMs?: number;
+
+  /**
+   * Minimum iterations to run regardless of timing (default: 5)
+   */
+  minIterations?: number;
+
+  /**
+   * Maximum iterations to run regardless of timing (default: 10000)
+   */
+  maxIterations?: number;
+
+  /**
+   * Number of warmup iterations before timing (default: 2)
+   */
+  warmupIterations?: number;
+
+  /**
+   * Whether to log debug information (default: false)
+   */
+  debug?: boolean;
+}
+
+export interface BenchmarkResult {
+  /**
+   * Number of iterations actually performed
+   */
+  iterations: number;
+
+  /**
+   * Total duration in milliseconds
+   */
+  totalDurationMs: number;
+
+  /**
+   * Average duration per iteration in milliseconds
+   */
+  avgIterationMs: number;
+
+  /**
+   * Whether the benchmark hit the timeout
+   */
+  timedOut: boolean;
+}
+
+/**
+ * Runs a benchmark operation adaptively based on the performance of the test environment.
+ *
+ * This harness:
+ * 1. Runs warmup iterations to estimate operation time
+ * 2. Calculates how many iterations can fit within the target duration
+ * 3. Runs the calculated number of iterations with a safety timeout
+ *
+ * @param operation - The async function to benchmark (should be a single iteration)
+ * @param options - Configuration options for the benchmark
+ * @returns Results of the benchmark run
+ */
+export async function runAdaptiveBenchmark(
+  operation: () => Promise<void>,
+  options: BenchmarkOptions = {},
+): Promise<BenchmarkResult> {
+  const {
+    targetDurationMs = 20_000,
+    maxTimeoutMs = 60_000,
+    minIterations = 5,
+    maxIterations = 10_000,
+    warmupIterations = 2,
+  } = options;
+
+  // Apply timing multiplier based on environment
+  const multiplier = getTimingMultiplier();
+  const adjustedTargetMs = targetDurationMs * multiplier;
+  const adjustedTimeoutMs = maxTimeoutMs * multiplier;
+
+  // Debug logging removed to prevent 'Cannot log after tests are done' errors
+
+  // Run warmup iterations
+
+  const warmupStart = Date.now();
+  for (let i = 0; i < warmupIterations; i++) {
+    await operation();
+  }
+  const warmupDuration = Date.now() - warmupStart;
+  const avgWarmupTime = warmupDuration / warmupIterations;
+
+  // Warmup timing debug info removed to prevent console logging issues
+
+  // Calculate target iterations based on warmup timing
+  // Add 10% safety margin to avoid overshooting
+  const safetyMargin = 0.9;
+  let targetIterations = Math.floor(
+    (adjustedTargetMs * safetyMargin) / avgWarmupTime,
+  );
+
+  // Clamp to min/max bounds
+  targetIterations = Math.max(
+    minIterations,
+    Math.min(maxIterations, targetIterations),
+  );
+
+  // Target iterations debug info removed to prevent console logging issues
+
+  // Set up timeout promise
+  let timeoutHandle: NodeJS.Timeout | undefined;
+  const timeoutPromise = new Promise<void>((_, reject) => {
+    timeoutHandle = setTimeout(() => {
+      reject(new Error(`Benchmark timeout after ${adjustedTimeoutMs}ms`));
+    }, adjustedTimeoutMs);
+  });
+
+  // Run the actual benchmark
+  const benchmarkStart = Date.now();
+  let completedIterations = 0;
+  let timedOut = false;
+
+  try {
+    // Run iterations with timeout protection
+    await Promise.race([
+      (async () => {
+        for (let i = 0; i < targetIterations; i++) {
+          await operation();
+          completedIterations++;
+
+          // Check if we're approaching the timeout
+          const elapsed = Date.now() - benchmarkStart;
+          if (elapsed > adjustedTimeoutMs * 0.95) {
+            // Approaching timeout - stopping early
+            break;
+          }
+        }
+      })(),
+      timeoutPromise,
+    ]);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("timeout")) {
+      timedOut = true;
+      // Benchmark timed out
+    } else {
+      throw error;
+    }
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+  }
+
+  const totalDuration = Date.now() - benchmarkStart;
+  const avgIterationTime = totalDuration / completedIterations;
+
+  const result: BenchmarkResult = {
+    iterations: completedIterations,
+    totalDurationMs: totalDuration,
+    avgIterationMs: avgIterationTime,
+    timedOut,
+  };
+
+  // Benchmark results debug info removed to prevent console logging issues
+
+  return result;
+}
+
+/**
+ * Helper function to run an operation with adaptive iterations and a callback.
+ * This is useful for tests that need to process results after each iteration.
+ *
+ * @param operation - The async function that returns a value
+ * @param callback - Function to process each result
+ * @param options - Configuration options for the benchmark
+ */
+export async function runAdaptiveBenchmarkWithCallback<T>(
+  operation: () => Promise<T>,
+  callback: (result: T, iteration: number) => void | Promise<void>,
+  options: BenchmarkOptions = {},
+): Promise<BenchmarkResult> {
+  let iterationCount = 0;
+
+  const wrappedOperation = async () => {
+    const result = await operation();
+    await callback(result, iterationCount++);
+  };
+
+  return runAdaptiveBenchmark(wrappedOperation, options);
+}

package/src/test-utils/debuglog-child.ts

@@ -1,13 +1,41 @@
 import { debugLogContext, isDebugEnabled } from "../debuglog";
 
+// Ensure clean process state on Windows
+process.on("uncaughtException", (err) => {
+  const errorMessage = err instanceof Error ? err.message : String(err);
+  process.stderr.write(
+    `Uncaught exception in debuglog-child: ${errorMessage}\n`,
+  );
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  const errorMessage =
+    reason instanceof Error ? reason.message : String(reason);
+  process.stderr.write(
+    `Unhandled rejection in debuglog-child: ${errorMessage}\n`,
+  );
+  process.exit(1);
+});
+
 try {
   const result = {
     isDebugEnabled: isDebugEnabled(),
     debugLogContext: debugLogContext(),
   };
-  console.log(JSON.stringify(result));
+  // Use process.stdout.write to ensure clean output
+  process.stdout.write(JSON.stringify(result));
   process.exit(0);
 } catch (err) {
-  console.error(err);
+  // Don't log the error object directly as it might have circular references
+  // that cause issues with Jest's message passing on Windows
+  const errorMessage = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error in debuglog-child: ${errorMessage}\n`);
+
+  // Also log stack trace for debugging
+  if (err instanceof Error && err.stack) {
+    process.stderr.write(`Stack trace:\n${err.stack}\n`);
+  }
+
   process.exit(1);
 }