@mimersql/node-mimer 1.0.0 → 1.0.2

package/src/resultset.cc

@@ -0,0 +1,161 @@
+// Copyright (c) 2026 Mimer Information Technology
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// See license for more details.
+
+#include "resultset.h"
+#include "connection.h"
+#include "helpers.h"
+
+Napi::FunctionReference MimerResultSetWrapper::constructor_;
+
+Napi::Object MimerResultSetWrapper::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(env, "ResultSet", {
+    InstanceMethod("fetchNext", &MimerResultSetWrapper::FetchNext),
+    InstanceMethod("getFields", &MimerResultSetWrapper::GetFields),
+    InstanceMethod("close", &MimerResultSetWrapper::Close),
+    InstanceMethod("isClosed", &MimerResultSetWrapper::IsClosed)
+  });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("ResultSet", func);
+  return exports;
+}
+
+/**
+ * Create a new ResultSet from C++.
+ * Passes the MimerStatement handle and columnCount as External values.
+ */
+Napi::Object MimerResultSetWrapper::NewInstance(Napi::Env env,
+                                                 MimerStatement stmt,
+                                                 int columnCount) {
+  Napi::External<MimerStatement> extStmt =
+      Napi::External<MimerStatement>::New(env, new MimerStatement(stmt));
+  Napi::Number colCount = Napi::Number::New(env, columnCount);
+  return constructor_.New({extStmt, colCount});
+}
+
+/**
+ * Constructor — receives External<MimerStatement> and columnCount.
+ */
+MimerResultSetWrapper::MimerResultSetWrapper(const Napi::CallbackInfo& info)
+  : Napi::ObjectWrap<MimerResultSetWrapper>(info),
+    stmt_(MIMERNULLHANDLE), columnCount_(0),
+    closed_(false), exhausted_(false), parentConnection_(nullptr) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2 || !info[0].IsExternal() || !info[1].IsNumber()) {
+    Napi::TypeError::New(env,
+        "ResultSet cannot be constructed directly; use connection.executeQuery()")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  MimerStatement* stmtPtr = info[0].As<Napi::External<MimerStatement>>().Data();
+  stmt_ = *stmtPtr;
+  delete stmtPtr;
+
+  columnCount_ = info[1].As<Napi::Number>().Int32Value();
+
+  // Cache column metadata once
+  CacheColumnMetadata(stmt_, columnCount_, colNames_, colTypes_);
+}
+
+MimerResultSetWrapper::~MimerResultSetWrapper() {
+  CloseInternal();
+}
+
+void MimerResultSetWrapper::SetParentConnection(MimerConnection* conn) {
+  parentConnection_ = conn;
+}
+
+/**
+ * Called by MimerConnection::Close() — close handles without unregistering.
+ */
+void MimerResultSetWrapper::Invalidate() {
+  if (!closed_ && stmt_ != MIMERNULLHANDLE) {
+    MimerCloseCursor(stmt_);
+    MimerEndStatement(&stmt_);
+  }
+  closed_ = true;
+  parentConnection_ = nullptr;
+}
+
+/**
+ * Close handles AND unregister from parent connection.
+ */
+void MimerResultSetWrapper::CloseInternal() {
+  if (!closed_ && stmt_ != MIMERNULLHANDLE) {
+    MimerCloseCursor(stmt_);
+    MimerEndStatement(&stmt_);
+  }
+  closed_ = true;
+  if (parentConnection_) {
+    parentConnection_->UnregisterResultSet(this);
+    parentConnection_ = nullptr;
+  }
+}
+
+/**
+ * Fetch the next row. Returns a JS object, or null when exhausted / closed.
+ */
+Napi::Value MimerResultSetWrapper::FetchNext(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (closed_ || exhausted_) {
+    return env.Null();
+  }
+
+  int rc = MimerFetch(stmt_);
+  if (rc == MIMER_SUCCESS) {
+    return FetchSingleRow(env, stmt_, columnCount_, colNames_, colTypes_);
+  }
+
+  // No more rows (or error) — mark exhausted
+  exhausted_ = true;
+  return env.Null();
+}
+
+/**
+ * Return column metadata array (same format as fields in query results).
+ */
+Napi::Value MimerResultSetWrapper::GetFields(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (closed_) {
+    return Napi::Array::New(env, 0);
+  }
+
+  return BuildFieldsArray(env, stmt_, columnCount_);
+}
+
+/**
+ * Explicitly close the cursor and release the statement handle.
+ */
+Napi::Value MimerResultSetWrapper::Close(const Napi::CallbackInfo& info) {
+  CloseInternal();
+  return Napi::Boolean::New(info.Env(), true);
+}
+
+Napi::Value MimerResultSetWrapper::IsClosed(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), closed_);
+}

package/src/resultset.h

@@ -0,0 +1,74 @@
+// Copyright (c) 2026 Mimer Information Technology
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// See license for more details.
+
+#ifndef MIMER_RESULTSET_H
+#define MIMER_RESULTSET_H
+
+#include <napi.h>
+#include <mimerapi.h>
+#include <vector>
+#include <string>
+
+class MimerConnection; // forward declaration
+
+/**
+ * MimerResultSetWrapper wraps an open Mimer cursor for row-at-a-time
+ * fetching.  Owns the MimerStatement handle (cursor already opened by
+ * MimerConnection::ExecuteQuery).
+ *
+ * Lifecycle follows the same pattern as MimerStmtWrapper:
+ *   - Invalidate()   — called by connection close (closes handles, no unregister)
+ *   - CloseInternal() — closes handles AND unregisters from parent
+ *   - Destructor calls CloseInternal()
+ */
+class MimerResultSetWrapper : public Napi::ObjectWrap<MimerResultSetWrapper> {
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object NewInstance(Napi::Env env, MimerStatement stmt,
+                                  int columnCount);
+  MimerResultSetWrapper(const Napi::CallbackInfo& info);
+  ~MimerResultSetWrapper();
+
+  void SetParentConnection(MimerConnection* conn);
+  void Invalidate();
+
+private:
+  MimerStatement stmt_;
+  int columnCount_;
+  std::vector<std::string> colNames_;
+  std::vector<int> colTypes_;
+  bool closed_;
+  bool exhausted_;
+  MimerConnection* parentConnection_;
+
+  // JS-exposed methods
+  Napi::Value FetchNext(const Napi::CallbackInfo& info);
+  Napi::Value GetFields(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value IsClosed(const Napi::CallbackInfo& info);
+
+  void CloseInternal();
+
+  static Napi::FunctionReference constructor_;
+};
+
+#endif // MIMER_RESULTSET_H

package/src/statement.cc

@@ -0,0 +1,201 @@
+// Copyright (c) 2026 Mimer Information Technology
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// See license for more details.
+
+#include "statement.h"
+#include "connection.h"
+#include "helpers.h"
+#include <sstream>
+
+Napi::FunctionReference MimerStmtWrapper::constructor_;
+
+/**
+ * Initialize the Statement class and export it
+ */
+Napi::Object MimerStmtWrapper::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(env, "Statement", {
+    InstanceMethod("execute", &MimerStmtWrapper::Execute),
+    InstanceMethod("close", &MimerStmtWrapper::Close)
+  });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("Statement", func);
+  return exports;
+}
+
+/**
+ * Create a new MimerStmtWrapper instance from C++.
+ * Called by MimerConnection::Prepare().
+ * We pass session and sql as External values through the constructor.
+ */
+Napi::Object MimerStmtWrapper::NewInstance(Napi::Env env, MimerSession session,
+                                            Napi::String sql) {
+  // Pass session pointer and SQL string to the JS constructor
+  Napi::External<MimerSession> extSession =
+      Napi::External<MimerSession>::New(env, new MimerSession(session));
+  return constructor_.New({extSession, sql});
+}
+
+/**
+ * Constructor - prepares the SQL statement.
+ * When called from NewInstance: info[0] = External<MimerSession>, info[1] = String (SQL)
+ */
+MimerStmtWrapper::MimerStmtWrapper(const Napi::CallbackInfo& info)
+  : Napi::ObjectWrap<MimerStmtWrapper>(info),
+    stmt_(MIMERNULLHANDLE), columnCount_(0), closed_(false),
+    parentConnection_(nullptr) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2 || !info[0].IsExternal() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Statement cannot be constructed directly; use connection.prepare()")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  MimerSession* sessionPtr = info[0].As<Napi::External<MimerSession>>().Data();
+  std::string sql = info[1].As<Napi::String>().Utf8Value();
+
+  int rc = MimerBeginStatement8(*sessionPtr, sql.c_str(), MIMER_FORWARD_ONLY, &stmt_);
+
+  // Clean up the allocated session pointer copy
+  delete sessionPtr;
+
+  if (rc < 0) {
+    ThrowMimerError(env, rc, "MimerBeginStatement8");
+    return;
+  }
+
+  columnCount_ = MimerColumnCount(stmt_);
+}
+
+/**
+ * Destructor - clean up statement handle if not already closed
+ */
+MimerStmtWrapper::~MimerStmtWrapper() {
+  if (!closed_ && stmt_ != MIMERNULLHANDLE) {
+    MimerEndStatement(&stmt_);
+    // Unregister from parent if it still exists
+    if (parentConnection_) {
+      parentConnection_->UnregisterStatement(this);
+      parentConnection_ = nullptr;
+    }
+  }
+}
+
+void MimerStmtWrapper::SetParentConnection(MimerConnection* conn) {
+  parentConnection_ = conn;
+}
+
+/**
+ * Called by MimerConnection::Close() to invalidate this statement.
+ * Closes the Mimer handle but does NOT unregister from the connection
+ * (the connection is clearing its own set).
+ */
+void MimerStmtWrapper::Invalidate() {
+  if (!closed_ && stmt_ != MIMERNULLHANDLE) {
+    MimerEndStatement(&stmt_);
+  }
+  closed_ = true;
+  parentConnection_ = nullptr;
+}
+
+/**
+ * Internal close: release the Mimer handle and unregister from the
+ * parent connection.
+ */
+void MimerStmtWrapper::CloseInternal() {
+  if (!closed_ && stmt_ != MIMERNULLHANDLE) {
+    MimerEndStatement(&stmt_);
+  }
+  closed_ = true;
+  if (parentConnection_) {
+    parentConnection_->UnregisterStatement(this);
+    parentConnection_ = nullptr;
+  }
+}
+
+/**
+ * Execute the prepared statement with optional parameters.
+ * Arguments: params (optional array)
+ * Returns: result object with rows and metadata
+ */
+Napi::Value MimerStmtWrapper::Execute(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (closed_) {
+    Napi::Error::New(env, "Statement is closed")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  // Bind parameters if provided
+  if (info.Length() >= 1 && info[0].IsArray()
+      && info[0].As<Napi::Array>().Length() > 0) {
+    Napi::Array params = info[0].As<Napi::Array>();
+    BindParameters(env, stmt_, params);
+    if (env.IsExceptionPending()) {
+      return env.Undefined();
+    }
+  }
+
+  bool hasResultSet = (columnCount_ > 0);
+  Napi::Object result = Napi::Object::New(env);
+  int rc;
+
+  if (hasResultSet) {
+    // Build column metadata before fetching rows
+    result.Set("fields", BuildFieldsArray(env, stmt_, columnCount_));
+
+    rc = MimerOpenCursor(stmt_);
+    if (rc < 0) {
+      ThrowMimerError(env, rc, "MimerOpenCursor");
+      return env.Undefined();
+    }
+
+    Napi::Array rows = FetchResults(env, stmt_, columnCount_);
+
+    // Close cursor but keep statement alive for reuse
+    MimerCloseCursor(stmt_);
+
+    result.Set("rows", rows);
+    result.Set("rowCount", Napi::Number::New(env, rows.Length()));
+  } else {
+    rc = MimerExecute(stmt_);
+    if (rc < 0) {
+      ThrowMimerError(env, rc, "MimerExecute");
+      return env.Undefined();
+    }
+    result.Set("rowCount", Napi::Number::New(env, rc));
+  }
+
+  return result;
+}
+
+/**
+ * Close the prepared statement and release its handle.
+ */
+Napi::Value MimerStmtWrapper::Close(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  CloseInternal();
+  return Napi::Boolean::New(env, true);
+}

package/src/statement.h

@@ -0,0 +1,74 @@
+// Copyright (c) 2026 Mimer Information Technology
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// See license for more details.
+
+#ifndef MIMER_STATEMENT_H
+#define MIMER_STATEMENT_H
+
+#include <napi.h>
+#include <mimerapi.h>
+
+class MimerConnection; // forward declaration
+
+/**
+ * MimerStmtWrapper wraps a Mimer prepared statement for reuse.
+ * Note: Cannot use 'MimerStatement' as class name since it's
+ * typedef'd in mimerapi.h.
+ *
+ * The statement handle persists across multiple execute() calls.
+ * After each execution with a cursor, we close the cursor but keep
+ * the prepared statement alive for reuse.
+ *
+ * Tracks its parent connection so it can be invalidated if the
+ * connection is closed while this statement is still open.
+ */
+class MimerStmtWrapper : public Napi::ObjectWrap<MimerStmtWrapper> {
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object NewInstance(Napi::Env env, MimerSession session,
+                                  Napi::String sql);
+  MimerStmtWrapper(const Napi::CallbackInfo& info);
+  ~MimerStmtWrapper();
+
+  // Called by MimerConnection to set the parent after construction
+  void SetParentConnection(MimerConnection* conn);
+
+  // Called by MimerConnection::Close() to invalidate this statement
+  // without the statement trying to unregister from the connection
+  void Invalidate();
+
+private:
+  MimerStatement stmt_;
+  int columnCount_;
+  bool closed_;
+  MimerConnection* parentConnection_;
+
+  // Methods exposed to JavaScript
+  Napi::Value Execute(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+
+  // Internal close logic shared by Close() and destructor
+  void CloseInternal();
+
+  static Napi::FunctionReference constructor_;
+};
+
+#endif // MIMER_STATEMENT_H

package/lib/find-mimer-library.js

@@ -1,154 +0,0 @@
-// Copyright (c) 2026 Mimer Information Technology
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//
-// See license for more details.
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Find the Mimer SQL shared library path for the current platform.
- * Returns the path (or library name for ld search) to load with koffi.load().
- */
-function findMimerLibrary() {
-  switch (process.platform) {
-    case 'linux':
-      return 'libmimerapi.so';
-
-    case 'darwin':
-      return '/usr/local/lib/libmimerapi.dylib';
-
-    case 'win32':
-      return findMimerWindows();
-
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
-}
-
-/**
- * Find mimapi64.dll on Windows.
- * Search order: MIMER_HOME → Registry → Program Files scan → defaults.
- */
-function findMimerWindows() {
-  // Helper to check if a directory contains the Mimer DLL
-  function hasDll(dir) {
-    if (!dir) return false;
-    const dllPath = path.join(dir, 'lib', 'mimapi64.dll');
-    return fs.existsSync(dllPath) ? dllPath : null;
-  }
-
-  // Try 1: MIMER_HOME environment variable
-  if (process.env.MIMER_HOME) {
-    const dll = hasDll(process.env.MIMER_HOME);
-    if (dll) return dll;
-  }
-
-  // Try 2: Windows Registry
-  try {
-    const { execSync } = require('child_process');
-    const regEnum = 'reg query "HKLM\\SOFTWARE\\Mimer\\Mimer SQL" 2>nul';
-    const output = execSync(regEnum, { encoding: 'utf8' });
-
-    const registryVersions = [];
-    for (const line of output.split('\n')) {
-      const versionMatch = line.match(/Mimer SQL\\(\d+\.\d+)\s*$/);
-      if (versionMatch) {
-        const version = versionMatch[1];
-        try {
-          const pathQuery = `reg query "HKLM\\SOFTWARE\\Mimer\\Mimer SQL\\${version}" /v PathName 2>nul`;
-          const pathOutput = execSync(pathQuery, { encoding: 'utf8' });
-          const pathMatch = pathOutput.match(/PathName\s+REG_SZ\s+(.+)/);
-          if (pathMatch && pathMatch[1]) {
-            const mimerPath = pathMatch[1].trim();
-            const dll = hasDll(mimerPath);
-            if (dll) {
-              registryVersions.push({ version, path: dll });
-            }
-          }
-        } catch (_) { /* skip */ }
-      }
-    }
-
-    if (registryVersions.length > 0) {
-      registryVersions.sort((a, b) => {
-        const va = a.version.split('.').map(Number);
-        const vb = b.version.split('.').map(Number);
-        if (va[0] !== vb[0]) return vb[0] - va[0];
-        return vb[1] - va[1];
-      });
-      return registryVersions[0].path;
-    }
-  } catch (_) { /* registry not available */ }
-
-  // Try 3: Program Files scan
-  const programFiles = [
-    process.env.ProgramFiles,
-    process.env['ProgramFiles(x86)'],
-  ].filter(Boolean);
-
-  const foundPaths = [];
-  for (const pf of programFiles) {
-    if (!fs.existsSync(pf)) continue;
-    try {
-      const entries = fs.readdirSync(pf, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith('Mimer SQL Experience')) {
-          const fullPath = path.join(pf, entry.name);
-          const dll = hasDll(fullPath);
-          if (dll) {
-            foundPaths.push({
-              path: dll,
-              version: entry.name.match(/(\d+\.\d+)/)?.[1] || '0.0',
-            });
-          }
-        }
-      }
-    } catch (_) { /* permission error */ }
-  }
-
-  if (foundPaths.length > 0) {
-    foundPaths.sort((a, b) => {
-      const va = a.version.split('.').map(Number);
-      const vb = b.version.split('.').map(Number);
-      if (va[0] !== vb[0]) return vb[0] - va[0];
-      return vb[1] - va[1];
-    });
-    return foundPaths[0].path;
-  }
-
-  // Try 4: Default locations
-  const defaultPaths = [
-    'C:\\Program Files\\Mimer SQL Experience 12.0',
-    'C:\\Program Files\\Mimer SQL Experience 11.0',
-  ];
-  for (const dp of defaultPaths) {
-    const dll = hasDll(dp);
-    if (dll) return dll;
-  }
-
-  throw new Error(
-    'Mimer SQL library not found. Please install Mimer SQL or set MIMER_HOME.'
-  );
-}
-
-module.exports = findMimerLibrary;