@photostructure/sqlite 0.3.0 → 0.4.0

package/src/aggregate_function.cpp

@@ -1,59 +1,89 @@
 #include "aggregate_function.h"
 
+#include <cinttypes>
 #include <cmath>
 #include <cstring>
 #include <limits>
 #include <unordered_map>
 #include <vector>
 
+#include "shims/node_errors.h"
 #include "sqlite_impl.h"
 
-namespace photostructure::sqlite {
+// Maximum safe integer for JavaScript numbers (2^53 - 1)
+static constexpr int64_t kMaxSafeJsInteger = 9007199254740991LL;
 
-// Static member definitions for ValueStorage
-std::unordered_map<int32_t, Napi::Reference<Napi::Value>>
-    ValueStorage::storage_;
-std::mutex ValueStorage::mutex_;
-std::atomic<int32_t> ValueStorage::next_id_{0};
+namespace photostructure::sqlite {
 
 // ValueStorage implementation
-int32_t ValueStorage::Store([[maybe_unused]] Napi::Env env, Napi::Value value) {
-  const std::lock_guard<std::mutex> lock(mutex_);
-  const int32_t id = ++next_id_;
-
-  // Try direct napi_value persistence instead of Napi::Reference
+int32_t ValueStorage::Store(Napi::Env env, Napi::Value value) {
+  AddonData *addon_data = GetAddonData(env);
+  if (!addon_data)
+    throw Napi::Error::New(env, "Addon data not found");
+
+  std::lock_guard<std::mutex> lock(addon_data->value_storage_mutex);
+  const int32_t id =
+      addon_data->next_value_id.fetch_add(1, std::memory_order_relaxed);
   try {
-    storage_[id] = Napi::Reference<Napi::Value>::New(value, 1);
+    addon_data->value_storage[id] = Napi::Reference<Napi::Value>::New(value, 1);
   } catch (...) {
     // If Reference creation fails, throw to let caller handle
     throw;
   }
-
   return id;
 }
 
 Napi::Value ValueStorage::Get(Napi::Env env, int32_t id) {
-  const std::lock_guard<std::mutex> lock(mutex_);
-  auto it = storage_.find(id);
-  return (it != storage_.end()) ? it->second.Value() : env.Undefined();
+  AddonData *addon_data = GetAddonData(env);
+  if (!addon_data)
+    return env.Null();
+
+  std::lock_guard<std::mutex> lock(addon_data->value_storage_mutex);
+  auto it = addon_data->value_storage.find(id);
+  if (it == addon_data->value_storage.end() || it->second.IsEmpty()) {
+    return env.Null();
+  }
+  return it->second.Value();
 }
 
-void ValueStorage::Remove(int32_t id) {
-  const std::lock_guard<std::mutex> lock(mutex_);
-  auto it = storage_.find(id);
-  if (it != storage_.end()) {
-    it->second.Reset();
-    storage_.erase(it);
+void ValueStorage::Remove(Napi::Env env, int32_t id) {
+  AddonData *addon_data = GetAddonData(env);
+  if (!addon_data)
+    return;
+
+  std::lock_guard<std::mutex> lock(addon_data->value_storage_mutex);
+  auto it = addon_data->value_storage.find(id);
+  if (it != addon_data->value_storage.end()) {
+    // Don't call Reset() here - it's unsafe during environment teardown on
+    // musl. The Cleanup() hook will reset all remaining references safely. For
+    // refs removed during normal operation, they'll be cleaned up by GC.
+    addon_data->value_storage.erase(it);
   }
 }
 
-CustomAggregate::CustomAggregate(Napi::Env env,
-                                 [[maybe_unused]] DatabaseSync *db,
+void CustomAggregate::CleanupHook(void *arg) {
+  // Called before environment teardown - safe to Reset() references here
+  auto *self = static_cast<CustomAggregate *>(arg);
+
+  if (!self->start_fn_.IsEmpty())
+    self->start_fn_.Reset();
+  if (!self->object_ref_.IsEmpty())
+    self->object_ref_.Reset();
+  if (!self->step_fn_.IsEmpty())
+    self->step_fn_.Reset();
+  if (!self->inverse_fn_.IsEmpty())
+    self->inverse_fn_.Reset();
+  if (!self->result_fn_.IsEmpty())
+    self->result_fn_.Reset();
+}
+
+CustomAggregate::CustomAggregate(Napi::Env env, DatabaseSync *db,
                                  bool use_bigint_args, Napi::Value start,
                                  Napi::Function step_fn,
                                  Napi::Function inverse_fn,
                                  Napi::Function result_fn)
-    : env_(env), use_bigint_args_(use_bigint_args), async_context_(nullptr) {
+    : env_(env), db_(db), use_bigint_args_(use_bigint_args),
+      async_context_(nullptr) {
   // Handle start value based on type
   if (start.IsNull()) {
     start_type_ = PRIMITIVE_NULL;
@@ -91,47 +121,35 @@ CustomAggregate::CustomAggregate(Napi::Env env,
     result_fn_ = Napi::Reference<Napi::Function>::New(result_fn, 1);
   }
 
+  // Register cleanup hook to Reset() references before environment teardown.
+  // This is required for worker thread support per Node-API best practices.
+  // See:
+  // https://nodejs.github.io/node-addon-examples/special-topics/context-awareness/
+  napi_add_env_cleanup_hook(env_, CleanupHook, this);
+
   // Don't create async context immediately - we'll create it lazily if needed
   async_context_ = nullptr;
 }
 
 CustomAggregate::~CustomAggregate() {
+  // Remove cleanup hook if still registered
+  napi_remove_env_cleanup_hook(env_, CleanupHook, this);
+
+  // Don't call Reset() on references here - CleanupHook already handled them,
+  // or the environment is being torn down and Reset() would be unsafe.
+
   // Check if environment is still valid before N-API operations.
-  // During shutdown, env_ may be torn down and N-API operations would crash.
-  // Try to create a handle scope - if this fails, env is invalid.
   napi_handle_scope scope;
   napi_status status = napi_open_handle_scope(env_, &scope);
 
   if (status == napi_ok) {
-    // Safe to do N-API operations
-    // Only clean up our own function references
-    // Do NOT touch any aggregate contexts - SQLite owns those
-    if (!step_fn_.IsEmpty()) {
-      step_fn_.Reset();
-    }
-    if (!inverse_fn_.IsEmpty()) {
-      inverse_fn_.Reset();
-    }
-    if (!result_fn_.IsEmpty()) {
-      result_fn_.Reset();
-    }
-    if (!start_fn_.IsEmpty()) {
-      start_fn_.Reset();
-    }
-    if (start_type_ == OBJECT && !object_ref_.IsEmpty()) {
-      object_ref_.Reset();
-    }
-
     // Clean up async context if it was created
     if (async_context_ != nullptr) {
       napi_async_destroy(env_, async_context_);
       async_context_ = nullptr;
     }
-
     napi_close_handle_scope(env_, scope);
   }
-  // If status != napi_ok, env is invalid - skip cleanup.
-  // References will be leaked, but that's better than crashing.
 }
 
 void CustomAggregate::xStep(sqlite3_context *ctx, int argc,
@@ -144,7 +162,10 @@ void CustomAggregate::xInverse(sqlite3_context *ctx, int argc,
   xStepBase(ctx, argc, argv, &CustomAggregate::inverse_fn_);
 }
 
-void CustomAggregate::xFinal(sqlite3_context *ctx) { xValueBase(ctx, true); }
+void CustomAggregate::xFinal(sqlite3_context *ctx) {
+  xValueBase(ctx, true);
+  DestroyAggregateData(ctx);
+}
 
 void CustomAggregate::xValue(sqlite3_context *ctx) { xValueBase(ctx, false); }
 
@@ -177,7 +198,25 @@ void CustomAggregate::xStepBase(
 
   if (!state->is_initialized) {
     // Initialize with the proper start value
-    Napi::Value start_val = self->GetStartValue();
+    Napi::Value start_val;
+
+    // If start is a function, call it to get the initial value
+    if (self->start_type_ == FUNCTION) {
+      Napi::Function start_func = self->start_fn_.Value();
+      napi_value result;
+      napi_status status = napi_call_function(
+          self->env_, self->env_.Undefined(), start_func, 0, nullptr, &result);
+
+      if (status != napi_ok || self->env_.IsExceptionPending()) {
+        // JavaScript exception is pending - let it propagate
+        self->db_->SetIgnoreNextSQLiteError(true);
+        sqlite3_result_error(ctx, "", 0);
+        return;
+      }
+      start_val = Napi::Value(self->env_, result);
+    } else {
+      start_val = self->GetStartValue();
+    }
 
     // Store the start value in the appropriate type
     if (start_val.IsNumber()) {
@@ -205,9 +244,9 @@ void CustomAggregate::xStepBase(
           std::min(buffer.Length(), sizeof(state->string_buffer) - 1);
       memcpy(state->string_buffer, buffer.Data(), copy_len);
       state->string_length = copy_len;
-    } else if (start_val.IsObject() && !start_val.IsArray() &&
+    } else if ((start_val.IsObject() || start_val.IsArray()) &&
                !start_val.IsBuffer()) {
-      // Store objects as JSON strings
+      // Store objects and arrays as JSON strings
       state->type = AggregateValue::OBJECT_JSON;
       // Use JSON.stringify to serialize the object
       std::string json_str = SafeJsonStringify(self->env_, start_val);
@@ -229,6 +268,7 @@ void CustomAggregate::xStepBase(
     }
 
     state->is_initialized = true;
+    state->xvalue_called = false;
   }
 
   // Get the JavaScript function
@@ -258,11 +298,17 @@ void CustomAggregate::xStepBase(
   case AggregateValue::BOOLEAN:
     current_value = Napi::Boolean::New(self->env_, state->bool_value);
     break;
-  case AggregateValue::BUFFER:
-    current_value = Napi::Buffer<uint8_t>::Copy(
-        self->env_, reinterpret_cast<const uint8_t *>(state->string_buffer),
-        state->string_length);
+  case AggregateValue::BUFFER: {
+    // Return Uint8Array to match Node.js node:sqlite behavior
+    auto array_buffer =
+        Napi::ArrayBuffer::New(self->env_, state->string_length);
+    if (state->string_length > 0) {
+      memcpy(array_buffer.Data(), state->string_buffer, state->string_length);
+    }
+    current_value = Napi::Uint8Array::New(self->env_, state->string_length,
+                                          array_buffer, 0);
     break;
+  }
   case AggregateValue::OBJECT_JSON: {
     // Parse JSON back to object using JSON.parse
     try {
@@ -288,7 +334,17 @@ void CustomAggregate::xStepBase(
 
   // Convert SQLite values to JavaScript
   for (int i = 0; i < argc; ++i) {
-    js_args.push_back(self->SqliteValueToJS(argv[i]));
+    Napi::Value js_val = self->SqliteValueToJS(argv[i]);
+
+    // Check if SqliteValueToJS threw an exception (e.g., ERR_OUT_OF_RANGE)
+    if (self->env_.IsExceptionPending()) {
+      // Ignore the SQLite error because a JavaScript exception is pending
+      self->db_->SetIgnoreNextSQLiteError(true);
+      sqlite3_result_error(ctx, "", 0);
+      return;
+    }
+
+    js_args.push_back(js_val);
   }
 
   // Convert to napi_value array
@@ -303,8 +359,10 @@ void CustomAggregate::xStepBase(
       napi_call_function(self->env_, self->env_.Undefined(), func,
                          raw_args.size(), raw_args.data(), &result);
 
-  if (status != napi_ok) {
-    sqlite3_result_error(ctx, "Error calling aggregate step function", -1);
+  if (status != napi_ok || self->env_.IsExceptionPending()) {
+    // JavaScript exception is pending - let it propagate
+    self->db_->SetIgnoreNextSQLiteError(true);
+    sqlite3_result_error(ctx, "", 0);
     return;
   }
 
@@ -348,11 +406,11 @@ void CustomAggregate::xStepBase(
         std::min(buffer.Length(), sizeof(state->string_buffer) - 1);
     memcpy(state->string_buffer, buffer.Data(), copy_len);
     state->string_length = copy_len;
-  } else if (result_val.IsObject() && !result_val.IsArray() &&
+  } else if ((result_val.IsObject() || result_val.IsArray()) &&
              !result_val.IsBuffer()) {
-    // Store objects as JSON strings
+    // Store objects and arrays as JSON strings
     state->type = AggregateValue::OBJECT_JSON;
-    // Use JSON.stringify to serialize the object
+    // Use JSON.stringify to serialize the object/array
     std::string json_str = SafeJsonStringify(self->env_, result_val);
 
     // If JSON is too long, use a simpler representation
@@ -408,11 +466,17 @@ void CustomAggregate::xValueBase(sqlite3_context *ctx, bool is_final) {
   case AggregateValue::BOOLEAN:
     current_value = Napi::Boolean::New(self->env_, state->bool_value);
     break;
-  case AggregateValue::BUFFER:
-    current_value = Napi::Buffer<uint8_t>::Copy(
-        self->env_, reinterpret_cast<const uint8_t *>(state->string_buffer),
-        state->string_length);
+  case AggregateValue::BUFFER: {
+    // Return Uint8Array to match Node.js node:sqlite behavior
+    auto array_buffer =
+        Napi::ArrayBuffer::New(self->env_, state->string_length);
+    if (state->string_length > 0) {
+      memcpy(array_buffer.Data(), state->string_buffer, state->string_length);
+    }
+    current_value = Napi::Uint8Array::New(self->env_, state->string_length,
+                                          array_buffer, 0);
     break;
+  }
   case AggregateValue::OBJECT_JSON: {
     // Parse JSON back to object using JSON.parse
     try {
@@ -435,9 +499,24 @@ void CustomAggregate::xValueBase(sqlite3_context *ctx, bool is_final) {
     break;
   }
 
-  // Apply result function if provided
+  // For window functions, xValue is called for each row and xFinal is called at
+  // the end. We should only call the result function once per actual result
+  // row.
+  // - xValue (is_final=false): Called for each row in window functions, call
+  // result function
+  // - xFinal (is_final=true): For regular aggregates, call result function
+  //                           For window aggregates (xvalue_called=true), skip
+  //                           result function
+  bool should_call_result = !is_final || !state->xvalue_called;
+
+  if (!is_final) {
+    // Mark that xValue was called (this is a window function)
+    state->xvalue_called = true;
+  }
+
+  // Apply result function if provided and appropriate
   Napi::Value final_value = current_value;
-  if (!self->result_fn_.IsEmpty()) {
+  if (should_call_result && !self->result_fn_.IsEmpty()) {
     Napi::Function result_func = self->result_fn_.Value();
 
     std::vector<napi_value> args = {current_value};
@@ -447,8 +526,10 @@ void CustomAggregate::xValueBase(sqlite3_context *ctx, bool is_final) {
         napi_call_function(self->env_, self->env_.Undefined(), result_func, 1,
                            args.data(), &result);
 
-    if (status != napi_ok) {
-      sqlite3_result_error(ctx, "Error calling aggregate result function", -1);
+    if (status != napi_ok || self->env_.IsExceptionPending()) {
+      // JavaScript exception is pending - let it propagate
+      self->db_->SetIgnoreNextSQLiteError(true);
+      sqlite3_result_error(ctx, "", 0);
       return;
     }
 
@@ -457,6 +538,14 @@ void CustomAggregate::xValueBase(sqlite3_context *ctx, bool is_final) {
 
   // Convert the final JavaScript value to SQLite result
   self->JSValueToSqliteResult(ctx, final_value);
+
+  // Check if JSValueToSqliteResult threw an exception (e.g., ERR_OUT_OF_RANGE)
+  if (self->env_.IsExceptionPending()) {
+    // Ignore the SQLite error because a JavaScript exception is pending
+    self->db_->SetIgnoreNextSQLiteError(true);
+    sqlite3_result_error(ctx, "", 0);
+    return;
+  }
 }
 
 CustomAggregate::AggregateData *
@@ -500,13 +589,16 @@ CustomAggregate::GetAggregate(sqlite3_context *ctx) {
 }
 
 void CustomAggregate::DestroyAggregateData(sqlite3_context *ctx) {
+  CustomAggregate *self =
+      static_cast<CustomAggregate *>(sqlite3_user_data(ctx));
   AggregateData *agg = static_cast<AggregateData *>(
       sqlite3_aggregate_context(ctx, sizeof(AggregateData)));
 
-  if (agg && agg->initialized) {
-    ValueStorage::Remove(agg->value_id);
-    agg->initialized = false;
+  if (!self || !agg || !agg->initialized) {
+    return;
   }
+  ValueStorage::Remove(self->env_, agg->value_id);
+  agg->initialized = false;
 }
 
 Napi::Value CustomAggregate::SqliteValueToJS(sqlite3_value *value) {
@@ -514,13 +606,24 @@ Napi::Value CustomAggregate::SqliteValueToJS(sqlite3_value *value) {
   case SQLITE_NULL:
     return env_.Null();
 
-  case SQLITE_INTEGER:
+  case SQLITE_INTEGER: {
+    sqlite3_int64 int_val = sqlite3_value_int64(value);
     if (use_bigint_args_) {
-      return Napi::BigInt::New(
-          env_, static_cast<int64_t>(sqlite3_value_int64(value)));
+      return Napi::BigInt::New(env_, static_cast<int64_t>(int_val));
+    } else if (std::abs(int_val) <= kMaxSafeJsInteger) {
+      return Napi::Number::New(env_, static_cast<double>(int_val));
     } else {
-      return Napi::Number::New(env_, sqlite3_value_int64(value));
+      // Value is outside safe integer range for JavaScript numbers
+      // Throw ERR_OUT_OF_RANGE directly - we're in a valid N-API context
+      char error_msg[128];
+      snprintf(error_msg, sizeof(error_msg),
+               "Value is too large to be represented as a JavaScript number: "
+               "%" PRId64,
+               static_cast<int64_t>(int_val));
+      node::THROW_ERR_OUT_OF_RANGE(env_, error_msg);
+      return env_.Undefined(); // Return undefined, exception is pending
     }
+  }
 
   case SQLITE_FLOAT:
     return Napi::Number::New(env_, sqlite3_value_double(value));
@@ -534,11 +637,14 @@ Napi::Value CustomAggregate::SqliteValueToJS(sqlite3_value *value) {
   case SQLITE_BLOB: {
     const void *blob = sqlite3_value_blob(value);
     int bytes = sqlite3_value_bytes(value);
+    // Return Uint8Array to match Node.js node:sqlite behavior
     if (blob && bytes > 0) {
-      return Napi::Buffer<uint8_t>::Copy(
-          env_, static_cast<const uint8_t *>(blob), static_cast<size_t>(bytes));
+      auto array_buffer = Napi::ArrayBuffer::New(env_, bytes);
+      memcpy(array_buffer.Data(), blob, bytes);
+      return Napi::Uint8Array::New(env_, bytes, array_buffer, 0);
     } else {
-      return Napi::Buffer<uint8_t>::New(env_, 0);
+      auto array_buffer = Napi::ArrayBuffer::New(env_, 0);
+      return Napi::Uint8Array::New(env_, 0, array_buffer, 0);
     }
   }
 
@@ -549,34 +655,17 @@ Napi::Value CustomAggregate::SqliteValueToJS(sqlite3_value *value) {
 
 void CustomAggregate::JSValueToSqliteResult(sqlite3_context *ctx,
                                             Napi::Value value) {
-  if (value.IsNull()) {
-    sqlite3_result_null(ctx);
-  } else if (value.IsUndefined()) {
+  if (value.IsNull() || value.IsUndefined()) {
     sqlite3_result_null(ctx);
-  } else if (value.IsNumber()) {
-    double num = value.As<Napi::Number>().DoubleValue();
-    if (std::isnan(num)) {
-      sqlite3_result_null(ctx);
-    } else if (std::floor(num) == num &&
-               num >= std::numeric_limits<int64_t>::min() &&
-               num <= std::numeric_limits<int64_t>::max()) {
-      sqlite3_result_int64(ctx, static_cast<int64_t>(num));
-    } else {
-      sqlite3_result_double(ctx, num);
-    }
   } else if (value.IsBoolean()) {
+    // Extension over Node.js: Convert booleans to 0/1
     sqlite3_result_int(ctx, value.As<Napi::Boolean>().Value() ? 1 : 0);
-  } else if (value.IsBigInt()) {
-    bool lossless;
-    int64_t val = value.As<Napi::BigInt>().Int64Value(&lossless);
-    if (lossless) {
-      sqlite3_result_int64(ctx, val);
-    } else {
-      sqlite3_result_error(ctx, "BigInt value is too large for SQLite", -1);
-    }
+  } else if (value.IsNumber()) {
+    // Match Node.js: numbers are stored as doubles
+    sqlite3_result_double(ctx, value.As<Napi::Number>().DoubleValue());
   } else if (value.IsString()) {
     std::string str = value.As<Napi::String>().Utf8Value();
-    sqlite3_result_text(ctx, str.c_str(), SafeCastToInt(str.length()),
+    sqlite3_result_text(ctx, str.c_str(), static_cast<int>(str.length()),
                         SQLITE_TRANSIENT);
   } else if (value.IsDataView()) {
     // IMPORTANT: Check DataView BEFORE IsBuffer() because N-API's IsBuffer()
@@ -591,21 +680,40 @@ void CustomAggregate::JSValueToSqliteResult(sqlite3_context *ctx,
     if (arrayBuffer.Data() != nullptr && byteLength > 0) {
       const uint8_t *data =
           static_cast<const uint8_t *>(arrayBuffer.Data()) + byteOffset;
-      sqlite3_result_blob(ctx, data, SafeCastToInt(byteLength),
+      sqlite3_result_blob(ctx, data, static_cast<int>(byteLength),
                           SQLITE_TRANSIENT);
     } else {
       sqlite3_result_zeroblob(ctx, 0);
     }
-  } else if (value.IsBuffer()) {
-    // Handles both Node.js Buffer and TypedArrays (Uint8Array, etc.)
-    Napi::Buffer<uint8_t> buffer = value.As<Napi::Buffer<uint8_t>>();
-    sqlite3_result_blob(ctx, buffer.Data(), SafeCastToInt(buffer.Length()),
-                        SQLITE_TRANSIENT);
+  } else if (value.IsTypedArray()) {
+    // Handles Uint8Array and other TypedArrays (but not DataView, handled
+    // above)
+    Napi::TypedArray arr = value.As<Napi::TypedArray>();
+    Napi::ArrayBuffer buf = arr.ArrayBuffer();
+    sqlite3_result_blob(
+        ctx, static_cast<const uint8_t *>(buf.Data()) + arr.ByteOffset(),
+        static_cast<int>(arr.ByteLength()), SQLITE_TRANSIENT);
+  } else if (value.IsBigInt()) {
+    // Check BigInt - must fit in int64
+    bool lossless;
+    int64_t bigint_val = value.As<Napi::BigInt>().Int64Value(&lossless);
+    if (!lossless) {
+      // BigInt too large for SQLite - throw ERR_OUT_OF_RANGE
+      node::THROW_ERR_OUT_OF_RANGE(
+          env_,
+          "BigInt value is too large to be represented as a SQLite integer");
+      return;
+    }
+    sqlite3_result_int64(ctx, static_cast<sqlite3_int64>(bigint_val));
+  } else if (value.IsPromise()) {
+    // Promises are not supported
+    sqlite3_result_error(
+        ctx, "Asynchronous user-defined functions are not supported", -1);
   } else {
-    // For other types (objects, functions, etc.), convert to string
-    std::string str = value.ToString().Utf8Value();
-    sqlite3_result_text(ctx, str.c_str(), SafeCastToInt(str.length()),
-                        SQLITE_TRANSIENT);
+    // Unsupported type
+    sqlite3_result_error(
+        ctx, "Returned JavaScript value cannot be converted to a SQLite value",
+        -1);
   }
 }
 

package/src/aggregate_function.h

@@ -19,15 +19,10 @@ class DatabaseSync;
 // Thread-safe external storage for N-API values
 // This solves the problem of storing N-API objects in SQLite-allocated memory
 class ValueStorage {
-private:
-  static std::unordered_map<int32_t, Napi::Reference<Napi::Value>> storage_;
-  static std::mutex mutex_;
-  static std::atomic<int32_t> next_id_;
-
 public:
   static int32_t Store(Napi::Env env, Napi::Value value);
   static Napi::Value Get(Napi::Env env, int32_t id);
-  static void Remove(int32_t id);
+  static void Remove(Napi::Env env, int32_t id);
 };
 
 class CustomAggregate {
@@ -46,6 +41,8 @@ public:
   static void xDestroy(void *self);
 
 private:
+  // Environment cleanup hook - called before environment teardown
+  static void CleanupHook(void *arg);
   // Comprehensive aggregate value storage (no Napi::Reference)
   struct AggregateValue {
     enum Type {
@@ -59,6 +56,7 @@ private:
     };
     Type type;
     bool is_initialized;
+    bool xvalue_called; // Track if xValue was called (for window functions)
     union {
       double number_value;
       bool bool_value;
@@ -94,6 +92,7 @@ private:
   Napi::Value GetStartValue();
 
   Napi::Env env_;
+  DatabaseSync *db_;
   bool use_bigint_args_;
 
   // Storage for start value - handle primitives and objects

package/src/binding.cpp

@@ -2,6 +2,7 @@
 #include <napi.h>
 #include <set>
 
+#include "aggregate_function.h"
 #include "sqlite_impl.h"
 
 namespace photostructure::sqlite {
@@ -17,20 +18,23 @@ void CleanupAddonData([[maybe_unused]] napi_env env, void *finalize_data,
     addon_data->databases.clear();
   }
 
-  // Clean up persistent references to prevent memory leaks
-  if (!addon_data->databaseSyncConstructor.IsEmpty()) {
-    addon_data->databaseSyncConstructor.Reset();
-  }
-  if (!addon_data->statementSyncConstructor.IsEmpty()) {
-    addon_data->statementSyncConstructor.Reset();
-  }
-  if (!addon_data->statementSyncIteratorConstructor.IsEmpty()) {
-    addon_data->statementSyncIteratorConstructor.Reset();
-  }
-  if (!addon_data->sessionConstructor.IsEmpty()) {
-    addon_data->sessionConstructor.Reset();
+  // Clean up ValueStorage references
+  {
+    std::lock_guard<std::mutex> lock(addon_data->value_storage_mutex);
+    for (auto &[id, ref] : addon_data->value_storage) {
+      if (!ref.IsEmpty()) {
+        ref.Reset();
+      }
+    }
+    addon_data->value_storage.clear();
   }
 
+  // Let Napi::FunctionReference destructors handle cleanup naturally.
+  // Explicitly calling Reset() during worker termination causes JIT corruption
+  // on Alpine/musl. The references will be cleaned up when addon_data is
+  // deleted. See: nodejs/node-addon-api#660,
+  // P02-investigate-flaky-native-crashes.md
+
   delete addon_data;
 }
 
@@ -75,6 +79,13 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     return exports;
   }
 
+  // Cache Object.create for creating objects with null prototype
+  Napi::Object global_object = env.Global().Get("Object").As<Napi::Object>();
+  Napi::Function object_create =
+      global_object.Get("create").As<Napi::Function>();
+  addon_data->objectCreateFn =
+      Napi::Reference<Napi::Function>::New(object_create);
+
   DatabaseSync::Init(env, exports);
   StatementSync::Init(env, exports);
   StatementSyncIterator::Init(env, exports);
@@ -217,18 +228,16 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
           }
         }
         if (db == nullptr) {
-          Napi::TypeError::New(
-              env, "The \"sourceDb\" argument must be a DatabaseSync object")
-              .ThrowAsJavaScriptException();
+          Napi::TypeError error = Napi::TypeError::New(
+              env, "The \"sourceDb\" argument must be an object.");
+          error.Set("code", Napi::String::New(env, "ERR_INVALID_ARG_TYPE"));
+          error.ThrowAsJavaScriptException();
           return env.Undefined();
         }
 
-        // Validate destination path is provided
-        if (info.Length() < 2) {
-          Napi::TypeError::New(env, "The \"destination\" argument is required")
-              .ThrowAsJavaScriptException();
-          return env.Undefined();
-        }
+        // Validate path is provided and valid - delegates to
+        // ValidateDatabasePath which will throw ERR_INVALID_ARG_TYPE with the
+        // proper message
 
         // Delegate to instance method: db.backup(destination, options?)
         std::vector<napi_value> args;