node-ctypes 0.1.3 → 0.1.4

package/lib/index.js

@@ -23,12 +23,7 @@ const getNativeModulePath = (moduleName, nativeFile, config = "Release") => {
   if (process.versions?.electron) {
     const electronProcess = process;
     if (electronProcess.resourcesPath) {
-      const unpackedPath = path.join(
-        electronProcess.resourcesPath,
-        "app.asar.unpacked",
-        "node_modules",
-        moduleName,
-      );
+      const unpackedPath = path.join(electronProcess.resourcesPath, "app.asar.unpacked", "node_modules", moduleName);
       if (existsSync(buildPath(unpackedPath))) {
         return buildPath(unpackedPath);
       }
@@ -36,9 +31,7 @@ const getNativeModulePath = (moduleName, nativeFile, config = "Release") => {
   }
 
   // Check in current working directory's node_modules
-  const cwdPath = buildPath(
-    path.join(process.cwd(), "node_modules", moduleName),
-  );
+  const cwdPath = buildPath(path.join(process.cwd(), "node_modules", moduleName));
   if (existsSync(cwdPath)) {
     return cwdPath;
   }
@@ -58,10 +51,7 @@ const getNativeModulePath = (moduleName, nativeFile, config = "Release") => {
     }
   }
 
-  throw new Error(
-    `Native module "${nativeFile}" not found for "${moduleName}". ` +
-      `Searched in Electron resources, node_modules, and local build.`,
-  );
+  throw new Error(`Native module "${nativeFile}" not found for "${moduleName}". ` + `Searched in Electron resources, node_modules, and local build.`);
 };
 
 // Load the native module
@@ -71,25 +61,13 @@ try {
 } catch (e) {
   const platform = process.platform;
   const arch = process.arch;
-  nativeModulePath = getNativeModulePath(
-    "node-ctypes",
-    `ctypes-${platform}-${arch}.node`,
-  );
+  nativeModulePath = getNativeModulePath("node-ctypes", `ctypes-${platform}-${arch}.node`);
 }
 const require = createRequire(path.join(process.cwd(), "index.js"));
 const native = require(nativeModulePath);
 
 // Re-esporta le classi native
-const {
-  Version,
-  Library,
-  FFIFunction,
-  Callback,
-  ThreadSafeCallback,
-  CType,
-  StructType,
-  ArrayType,
-} = native;
+const { Version, Library, FFIFunction, Callback, ThreadSafeCallback, CType, StructType, ArrayType } = native;
 
 // Tipi predefiniti
 const types = native.types;
@@ -112,10 +90,7 @@ function _toNativeType(type) {
     return type._type;
   }
   // Struct/Union classes pass through
-  if (
-    typeof type === "function" &&
-    (type.prototype instanceof Structure || type.prototype instanceof Union)
-  ) {
+  if (typeof type === "function" && (type.prototype instanceof Structure || type.prototype instanceof Union)) {
     return type;
   }
   // Native CType objects pass through
@@ -132,18 +107,6 @@ function _toNativeTypes(types) {
   return types.map(_toNativeType);
 }
 
-// ============================================================================
-// Type Lookup Tables
-// Centralizes type information to avoid duplicated switch statements
-// ============================================================================
-
-// TYPE_READERS removed - using SimpleCData._reader directly
-
-// TYPE_WRITERS removed - using SimpleCData._writer directly
-
-/** @type {Map<string, number>} */
-// TYPE_SIZES removed - using SimpleCData._size directly
-
 /**
  * Carica una libreria dinamica
  * @param {string|null} libPath - Percorso della libreria o null per l'eseguibile corrente
@@ -153,6 +116,62 @@ function load(libPath) {
   return new Library(libPath);
 }
 
+/**
+ * Wrapper per funzioni con sintassi Python-like ctypes (argtypes/restype)
+ */
+class FunctionWrapper {
+  constructor(cdll, name) {
+    const argtypes = [];
+    let restype = undefined;
+    let cachedFunc = null;
+
+    // Create a function and proxy it to make it callable
+    const func = (...args) => {
+      if (restype === undefined) {
+        throw new Error(`Function ${name}: restype not set`);
+      }
+      if (!cachedFunc) {
+        cachedFunc = cdll.func(name, restype, argtypes);
+      }
+      return cachedFunc(...args);
+    };
+
+    // Proxy the function to intercept property access
+    return new Proxy(func, {
+      get(target, prop) {
+        if (prop === "argtypes") return argtypes;
+        if (prop === "restype") return restype;
+        if (prop === "errcheck") return cachedFunc ? cachedFunc.errcheck : undefined;
+        return target[prop];
+      },
+      set(target, prop, value) {
+        if (prop === "argtypes") {
+          argtypes.splice(0, argtypes.length, ...value);
+          cachedFunc = null; // Invalidate cache
+          return true;
+        }
+        if (prop === "restype") {
+          restype = value;
+          cachedFunc = null; // Invalidate cache
+          return true;
+        }
+        if (prop === "errcheck") {
+          if (!cachedFunc) {
+            if (restype === undefined) {
+              throw new Error(`Function ${name}: restype not set`);
+            }
+            cachedFunc = cdll.func(name, restype, argtypes);
+          }
+          cachedFunc.errcheck = value;
+          return true;
+        }
+        target[prop] = value;
+        return true;
+      },
+    });
+  }
+}
+
 /**
  * Wrapper conveniente per CDLL (come in Python ctypes)
  */
@@ -160,6 +179,18 @@ class CDLL {
   constructor(libPath) {
     this._lib = new Library(libPath);
     this._cache = new Map();
+
+    // Return a proxy to enable Python-like syntax: libc.abs.argtypes = [...]; libc.abs.restype = ...; libc.abs(...)
+    return new Proxy(this, {
+      get(target, prop, receiver) {
+        // Allow access to existing properties/methods
+        if (prop in target || typeof prop !== "string") {
+          return Reflect.get(target, prop, receiver);
+        }
+        // Assume it's a function name from the library
+        return new FunctionWrapper(target, prop);
+      },
+    });
   }
 
   /**
@@ -177,44 +208,99 @@ class CDLL {
       return this._cache.get(cacheKey);
     }
 
-    const ffiFunc = this._lib.func(
-      name,
-      _toNativeType(returnType),
-      _toNativeTypes(argTypes),
-      options,
-    );
-
-    // Crea wrapper minimo ottimizzato
-    // Estrae ._buffer solo da argomenti che sono oggetti NON-Buffer
-    const callMethod = function (...args) {
-      // Process args: extract _buffer from struct proxies
-      const processedArgs = [];
-
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        // Check for _buffer FIRST (handles Proxy-wrapped structs)
-        // This avoids calling Buffer.isBuffer() on Proxy which can cause issues
-        if (arg && typeof arg === "object") {
-          // Check for struct proxy FIRST - accessing _buffer on Proxy is safe
-          // but Buffer.isBuffer(proxy) can cause hangs
-          if (arg._buffer !== undefined && Buffer.isBuffer(arg._buffer)) {
-            // Struct proxy or object with _buffer
-            processedArgs.push(arg._buffer);
-          } else if (Buffer.isBuffer(arg)) {
-            // Already a buffer, use directly
-            processedArgs.push(arg);
+    const ffiFunc = this._lib.func(name, _toNativeType(returnType), _toNativeTypes(argTypes), options);
+
+    // =========================================================================
+    // OPTIMIZATION: Create specialized wrapper based on argument types
+    // For primitive-only args, bypass the processing loop entirely
+    // =========================================================================
+
+    const argCount = argTypes.length;
+
+    // Check if all args are primitive types (no structs/buffers that need _buffer extraction)
+    const allPrimitive = argTypes.every((t) => {
+      if (typeof t === "function" && t._isSimpleCData) {
+        // SimpleCData types that are NOT pointers are primitive
+        const typeName = t._type;
+        return typeName !== "pointer" && typeName !== "char_p" && typeName !== "wchar_p";
+      }
+      if (typeof t === "string") {
+        return t !== "pointer" && t !== "char_p" && t !== "wchar_p" && t !== "void_p";
+      }
+      // CType objects from native - check if it's a pointer type
+      if (t && typeof t === "object" && t.name) {
+        return !t.name.includes("pointer") && !t.name.includes("char_p");
+      }
+      return false;
+    });
+
+    let callMethod;
+
+    if (argCount === 0) {
+      // FAST PATH: No arguments - direct call
+      callMethod = function () {
+        return ffiFunc.call();
+      };
+    } else if (allPrimitive) {
+      // FAST PATH: All primitive args - direct call without processing
+      switch (argCount) {
+        case 1:
+          callMethod = function (a0) {
+            return ffiFunc.call(a0);
+          };
+          break;
+        case 2:
+          callMethod = function (a0, a1) {
+            return ffiFunc.call(a0, a1);
+          };
+          break;
+        case 3:
+          callMethod = function (a0, a1, a2) {
+            return ffiFunc.call(a0, a1, a2);
+          };
+          break;
+        case 4:
+          callMethod = function (a0, a1, a2, a3) {
+            return ffiFunc.call(a0, a1, a2, a3);
+          };
+          break;
+        default:
+          // Fallback for many args
+          callMethod = function (...args) {
+            return ffiFunc.call(...args);
+          };
+      }
+    } else {
+      // SLOW PATH: Has buffer/struct args - need to extract _buffer
+      callMethod = function (...args) {
+        const processedArgs = [];
+
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          // Check for _buffer FIRST (handles Proxy-wrapped structs)
+          // This avoids calling Buffer.isBuffer() on Proxy which can cause issues
+          if (arg && typeof arg === "object") {
+            // Check for struct proxy FIRST - accessing _buffer on Proxy is safe
+            // but Buffer.isBuffer(proxy) can cause hangs
+            if (arg._buffer !== undefined && Buffer.isBuffer(arg._buffer)) {
+              // Struct proxy or object with _buffer
+              processedArgs.push(arg._buffer);
+            } else if (Buffer.isBuffer(arg)) {
+              // Already a buffer, use directly
+              processedArgs.push(arg);
+            } else {
+              // Other object, pass as-is
+              processedArgs.push(arg);
+            }
           } else {
-            // Other object, pass as-is
+            // Primitive value (number, string, bigint, null, undefined)
             processedArgs.push(arg);
           }
-        } else {
-          // Primitive value (number, string, bigint, null, undefined)
-          processedArgs.push(arg);
         }
-      }
 
-      return ffiFunc.call(...processedArgs);
-    };
+        return ffiFunc.call(...processedArgs);
+      };
+    }
 
     // Aggiungi metadata come proprietà non-enumerable per non interferire
     Object.defineProperties(callMethod, {
@@ -256,11 +342,7 @@ class CDLL {
    * @returns {Object} Oggetto callback con proprietà pointer e metodi
    */
   callback(fn, returnType, argTypes = []) {
-    return this._lib.callback(
-      _toNativeType(returnType),
-      _toNativeTypes(argTypes),
-      fn,
-    );
+    return this._lib.callback(_toNativeType(returnType), _toNativeTypes(argTypes), fn);
   }
 
   /**
@@ -306,11 +388,7 @@ class WinDLL extends CDLL {
  * @returns {Object} Oggetto con .pointer (BigInt), .release()
  */
 function callback(fn, returnType, argTypes = []) {
-  const cb = new Callback(
-    fn,
-    _toNativeType(returnType),
-    _toNativeTypes(argTypes),
-  );
+  const cb = new Callback(fn, _toNativeType(returnType), _toNativeTypes(argTypes));
 
   return {
     get pointer() {
@@ -338,11 +416,7 @@ function callback(fn, returnType, argTypes = []) {
  * @returns {Object} Oggetto con .pointer (BigInt), .release()
  */
 function threadSafeCallback(fn, returnType, argTypes = []) {
-  const cb = new ThreadSafeCallback(
-    fn,
-    _toNativeType(returnType),
-    _toNativeTypes(argTypes),
-  );
+  const cb = new ThreadSafeCallback(fn, _toNativeType(returnType), _toNativeTypes(argTypes));
 
   return {
     get pointer() {
@@ -547,12 +621,7 @@ function sizeof(type) {
   }
 
   // SimpleCData instance (e.g., sizeof(new c_uint64()))
-  if (
-    type &&
-    type._buffer &&
-    type.constructor &&
-    type.constructor._isSimpleCData
-  ) {
+  if (type && type._buffer && type.constructor && type.constructor._isSimpleCData) {
     return type.constructor._size;
   }
 
@@ -569,26 +638,16 @@ function sizeof(type) {
   }
 
   // Struct type
-  if (
-    typeof type === "object" &&
-    type !== null &&
-    typeof type.size === "number"
-  ) {
+  if (typeof type === "object" && type !== null && typeof type.size === "number") {
     return type.size;
   }
 
   // Array type
-  if (
-    typeof type === "object" &&
-    type !== null &&
-    typeof type.getSize === "function"
-  ) {
+  if (typeof type === "object" && type !== null && typeof type.getSize === "function") {
     return type.getSize();
   }
 
-  throw new TypeError(
-    `sizeof: unsupported type. Use SimpleCData classes like c_int32, c_uint64, etc.`,
-  );
+  throw new TypeError(`sizeof: unsupported type. Use SimpleCData classes like c_int32, c_uint64, etc.`);
 }
 
 /**
@@ -690,8 +749,7 @@ function ptrToBuffer(address, size) {
  * @returns {Object} Tipo puntatore
  */
 function POINTER(baseType) {
-  const baseSize =
-    typeof baseType === "object" ? baseType.size : sizeof(baseType);
+  const baseSize = typeof baseType === "object" ? baseType.size : sizeof(baseType);
   const typeName = typeof baseType === "object" ? "struct" : baseType;
 
   return {
@@ -794,9 +852,7 @@ function union(fields) {
     else {
       // Validate type is a SimpleCData class
       if (!(typeof type === "function" && type._isSimpleCData)) {
-        throw new TypeError(
-          `union field "${name}": type must be a SimpleCData class, struct, union, or array`,
-        );
+        throw new TypeError(`union field "${name}": type must be a SimpleCData class, struct, union, or array`);
       }
       size = type._size;
       alignment = Math.min(size, native.POINTER_SIZE);
@@ -854,13 +910,7 @@ function union(fields) {
           if (prop === Symbol.iterator) return undefined;
 
           // Handle Buffer/TypedArray properties FIRST before field checks
-          if (
-            prop === "length" ||
-            prop === "byteLength" ||
-            prop === "byteOffset" ||
-            prop === "buffer" ||
-            prop === "BYTES_PER_ELEMENT"
-          ) {
+          if (prop === "length" || prop === "byteLength" || prop === "byteOffset" || prop === "buffer" || prop === "BYTES_PER_ELEMENT") {
             return target[prop];
           }
 
@@ -895,10 +945,7 @@ function union(fields) {
           return fieldDefs.map((f) => f.name);
         },
         getOwnPropertyDescriptor(target, prop) {
-          if (
-            typeof prop === "string" &&
-            (fieldMap.has(prop) || prop === "_buffer" || prop === "toObject")
-          ) {
+          if (typeof prop === "string" && (fieldMap.has(prop) || prop === "_buffer" || prop === "toObject")) {
             return {
               enumerable: prop !== "_buffer" && prop !== "toObject",
               configurable: true,
@@ -928,13 +975,7 @@ function union(fields) {
 
       // Bit field
       if (field.isBitField) {
-        return _readBitField(
-          buf,
-          field.offset,
-          field.type,
-          field.bitOffset,
-          field.bitSize,
-        );
+        return _readBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize);
       }
 
       // Nested struct
@@ -948,19 +989,11 @@ function union(fields) {
             if (prop === Symbol.toStringTag) return "NestedUnionInstance";
             if (prop === Symbol.iterator) return undefined;
             // Handle Buffer/TypedArray properties
-            if (
-              prop === "length" ||
-              prop === "byteLength" ||
-              prop === "byteOffset" ||
-              prop === "buffer" ||
-              prop === "BYTES_PER_ELEMENT"
-            ) {
+            if (prop === "length" || prop === "byteLength" || prop === "byteOffset" || prop === "buffer" || prop === "BYTES_PER_ELEMENT") {
               return target[prop];
             }
             if (typeof prop === "string" && field.type.fields) {
-              if (
-                field.type.fields.some((f) => f.name === prop && !f.isAnonymous)
-              ) {
+              if (field.type.fields.some((f) => f.name === prop && !f.isAnonymous)) {
                 return field.type.get(target, prop);
               }
             }
@@ -970,9 +1003,7 @@ function union(fields) {
           },
           set(target, prop, value, receiver) {
             if (typeof prop === "string" && field.type.fields) {
-              if (
-                field.type.fields.some((f) => f.name === prop && !f.isAnonymous)
-              ) {
+              if (field.type.fields.some((f) => f.name === prop && !f.isAnonymous)) {
                 field.type.set(target, prop, value);
                 return true;
               }
@@ -987,16 +1018,10 @@ function union(fields) {
             return Reflect.has(target, prop);
           },
           ownKeys(target) {
-            return (field.type.fields || [])
-              .filter((f) => !f.isAnonymous)
-              .map((f) => f.name);
+            return (field.type.fields || []).filter((f) => !f.isAnonymous).map((f) => f.name);
           },
           getOwnPropertyDescriptor(target, prop) {
-            if (
-              typeof prop === "string" &&
-              field.type.fields &&
-              field.type.fields.some((f) => f.name === prop)
-            ) {
+            if (typeof prop === "string" && field.type.fields && field.type.fields.some((f) => f.name === prop)) {
               return {
                 enumerable: true,
                 configurable: true,
@@ -1010,9 +1035,7 @@ function union(fields) {
 
       // Array
       if (field.isArray) {
-        return field.type.wrap(
-          buf.subarray(field.offset, field.offset + field.size),
-        );
+        return field.type.wrap(buf.subarray(field.offset, field.offset + field.size));
       }
 
       // Tipo base
@@ -1038,14 +1061,7 @@ function union(fields) {
 
       // Bit field
       if (field.isBitField) {
-        _writeBitField(
-          buf,
-          field.offset,
-          field.type,
-          field.bitOffset,
-          field.bitSize,
-          value,
-        );
+        _writeBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize, value);
         return;
       }
 
@@ -1054,10 +1070,7 @@ function union(fields) {
         if (Buffer.isBuffer(value)) {
           value.copy(buf, field.offset, 0, field.size);
         } else if (typeof value === "object") {
-          const nestedBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
           for (const [k, v] of Object.entries(value)) {
             field.type.set(nestedBuf, k, v);
           }
@@ -1070,9 +1083,7 @@ function union(fields) {
         if (Buffer.isBuffer(value)) {
           value.copy(buf, field.offset, 0, field.size);
         } else if (Array.isArray(value)) {
-          const wrapped = field.type.wrap(
-            buf.subarray(field.offset, field.offset + field.size),
-          );
+          const wrapped = field.type.wrap(buf.subarray(field.offset, field.offset + field.size));
           for (let i = 0; i < Math.min(value.length, field.type.length); i++) {
             wrapped[i] = value[i];
           }
@@ -1090,11 +1101,7 @@ function union(fields) {
     toObject(bufOrObj) {
       // Se è già un object (non buffer), ritorna così com'è
       if (!Buffer.isBuffer(bufOrObj)) {
-        if (
-          bufOrObj &&
-          bufOrObj._buffer &&
-          bufOrObj._buffer.length === maxSize
-        ) {
+        if (bufOrObj && bufOrObj._buffer && bufOrObj._buffer.length === maxSize) {
           return bufOrObj; // Già convertito
         }
         // Se è un plain object, convertilo in union
@@ -1128,13 +1135,7 @@ function union(fields) {
         Object.defineProperty(obj, field.name, {
           get() {
             if (field.isBitField) {
-              return _readBitField(
-                buf,
-                0,
-                field.type,
-                field.bitOffset,
-                field.bitSize,
-              );
+              return _readBitField(buf, 0, field.type, field.bitOffset, field.bitSize);
             } else if (field.isNested) {
               // Cache nested objects per evitare di ricrearli ogni volta
               if (!nestedCache.has(field.name)) {
@@ -1152,14 +1153,7 @@ function union(fields) {
           },
           set(value) {
             if (field.isBitField) {
-              _writeBitField(
-                buf,
-                0,
-                field.type,
-                field.bitOffset,
-                field.bitSize,
-                value,
-              );
+              _writeBitField(buf, 0, field.type, field.bitOffset, field.bitSize, value);
             } else {
               writeValue(buf, field.type, value, 0);
             }
@@ -1229,12 +1223,7 @@ class Structure {
     buf.fill(0);
 
     // Support positional args: new Point(10,20)
-    if (
-      args.length === 1 &&
-      typeof args[0] === "object" &&
-      !Array.isArray(args[0]) &&
-      !Buffer.isBuffer(args[0])
-    ) {
+    if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0]) && !Buffer.isBuffer(args[0])) {
       const initial = args[0];
       for (const [k, v] of Object.entries(initial)) {
         def.set(buf, k, v);
@@ -1312,8 +1301,7 @@ class Structure {
         return Reflect.set(target, prop, value, receiver);
       },
       has(target, prop) {
-        if (prop === "_buffer" || prop === "_structDef" || prop === "toObject")
-          return true;
+        if (prop === "_buffer" || prop === "_structDef" || prop === "toObject") return true;
         if (typeof prop === "string" && fieldMap.has(prop)) return true;
         if (typeof prop === "string" && anonFieldNames.has(prop)) return true;
         return Reflect.has(target, prop);
@@ -1332,10 +1320,7 @@ class Structure {
         return keys;
       },
       getOwnPropertyDescriptor(target, prop) {
-        if (
-          typeof prop === "string" &&
-          (fieldMap.has(prop) || anonFieldNames.has(prop))
-        ) {
+        if (typeof prop === "string" && (fieldMap.has(prop) || anonFieldNames.has(prop))) {
           return {
             enumerable: true,
             configurable: true,
@@ -1465,19 +1450,11 @@ class Structure {
 
   // Direct typed array access for numeric fields (maximum performance)
   getInt32Array(offset = 0, length) {
-    return new Int32Array(
-      this.__buffer.buffer,
-      this.__buffer.byteOffset + offset,
-      length,
-    );
+    return new Int32Array(this.__buffer.buffer, this.__buffer.byteOffset + offset, length);
   }
 
   getFloat64Array(offset = 0, length) {
-    return new Float64Array(
-      this.__buffer.buffer,
-      this.__buffer.byteOffset + offset,
-      length,
-    );
+    return new Float64Array(this.__buffer.buffer, this.__buffer.byteOffset + offset, length);
   }
 
   // Get raw buffer slice for external operations
@@ -1545,9 +1522,7 @@ class Union extends Structure {
 function array(elementType, count) {
   // Validate elementType is a SimpleCData class
   if (!(typeof elementType === "function" && elementType._isSimpleCData)) {
-    throw new TypeError(
-      "array elementType must be a SimpleCData class (e.g., c_int32, c_uint8)",
-    );
+    throw new TypeError("array elementType must be a SimpleCData class (e.g., c_int32, c_uint8)");
   }
 
   const elementSize = elementType._size;
@@ -1666,12 +1641,7 @@ function array(elementType, count) {
         }
       } else if (typeof values === "string") {
         for (let i = 0; i < Math.min(values.length, count); i++) {
-          writeValue(
-            buffer,
-            elementType,
-            values.charCodeAt(i),
-            i * sizeof(elementType),
-          );
+          writeValue(buffer, elementType, values.charCodeAt(i), i * sizeof(elementType));
         }
       }
       return wrap(buffer);
@@ -1786,15 +1756,7 @@ function _initWinError() {
     _win_error_funcs = {
       GetLastError: kernel32.func("GetLastError", c_uint32, []),
       SetLastError: kernel32.func("SetLastError", c_void, [c_uint32]),
-      FormatMessageW: kernel32.func("FormatMessageW", c_uint32, [
-        c_uint32,
-        c_void_p,
-        c_uint32,
-        c_uint32,
-        c_void_p,
-        c_uint32,
-        c_void_p,
-      ]),
+      FormatMessageW: kernel32.func("FormatMessageW", c_uint32, [c_uint32, c_void_p, c_uint32, c_uint32, c_void_p, c_uint32, c_void_p]),
       _lib: kernel32,
     };
   } catch (e) {
@@ -1893,9 +1855,7 @@ function bitfield(baseType, bits) {
   const maxBits = baseSize * 8;
 
   if (bits < 1 || bits > maxBits) {
-    throw new Error(
-      `Bit field size must be between 1 and ${maxBits} for ${baseType}`,
-    );
+    throw new Error(`Bit field size must be between 1 and ${maxBits} for ${baseType}`);
   }
 
   return {
@@ -1910,22 +1870,14 @@ function bitfield(baseType, bits) {
  * Helper per verificare se un tipo è una struct
  */
 function _isStruct(type) {
-  return (
-    typeof type === "object" &&
-    type !== null &&
-    typeof type.size === "number" &&
-    Array.isArray(type.fields) &&
-    typeof type.create === "function"
-  );
+  return typeof type === "object" && type !== null && typeof type.size === "number" && Array.isArray(type.fields) && typeof type.create === "function";
 }
 
 /**
  * Helper per verificare se un tipo è un array type
  */
 function _isArrayType(type) {
-  return (
-    typeof type === "object" && type !== null && type._isArrayType === true
-  );
+  return typeof type === "object" && type !== null && type._isArrayType === true;
 }
 
 /**
@@ -2007,8 +1959,7 @@ function _writeBitField(buf, offset, baseType, bitOffset, bitSize, newValue) {
   if (baseSize === 8) {
     const mask = (1n << BigInt(bitSize)) - 1n;
     const clearMask = ~(mask << BigInt(bitOffset));
-    value =
-      (value & clearMask) | ((BigInt(newValue) & mask) << BigInt(bitOffset));
+    value = (value & clearMask) | ((BigInt(newValue) & mask) << BigInt(bitOffset));
   } else {
     const mask = (1 << bitSize) - 1;
     const clearMask = ~(mask << bitOffset);
@@ -2046,12 +1997,7 @@ function struct(fields, options = {}) {
     let fieldDef;
 
     // Caso 0: Anonymous field - { type: SomeStruct, anonymous: true }
-    if (
-      typeof type === "object" &&
-      type !== null &&
-      type.anonymous === true &&
-      type.type
-    ) {
+    if (typeof type === "object" && type !== null && type.anonymous === true && type.type) {
       // Reset bit field state
       currentBitFieldBase = null;
       currentBitOffset = 0;
@@ -2087,9 +2033,7 @@ function struct(fields, options = {}) {
       const alignment = packed ? 1 : Math.min(baseSize, native.POINTER_SIZE);
 
       // Verifica se possiamo continuare nel bit field corrente
-      const canContinue =
-        currentBitFieldBase === baseType &&
-        currentBitOffset + bits <= baseSize * 8;
+      const canContinue = currentBitFieldBase === baseType && currentBitOffset + bits <= baseSize * 8;
 
       if (!canContinue) {
         // Inizia un nuovo bit field
@@ -2190,9 +2134,7 @@ function struct(fields, options = {}) {
 
       // Validate type is a SimpleCData class
       if (!(typeof type === "function" && type._isSimpleCData)) {
-        throw new TypeError(
-          `struct field "${name}": type must be a SimpleCData class, struct, union, or array`,
-        );
+        throw new TypeError(`struct field "${name}": type must be a SimpleCData class, struct, union, or array`);
       }
 
       const size = type._size;
@@ -2252,9 +2194,7 @@ function struct(fields, options = {}) {
     if (fieldType && fieldType._isSimpleCData) {
       const fieldOffset = offset; // Capture offset for closure
       fieldReaders.set(name, (buf) => fieldType._reader(buf, fieldOffset));
-      fieldWriters.set(name, (buf, val) =>
-        fieldType._writer(buf, fieldOffset, val),
-      );
+      fieldWriters.set(name, (buf, val) => fieldType._writer(buf, fieldOffset, val));
     }
   }
 
@@ -2303,13 +2243,7 @@ function struct(fields, options = {}) {
 
           // Handle Buffer/TypedArray properties FIRST before field checks
           // TypedArray methods need direct access to avoid Proxy interference
-          if (
-            prop === "length" ||
-            prop === "byteLength" ||
-            prop === "byteOffset" ||
-            prop === "buffer" ||
-            prop === "BYTES_PER_ELEMENT"
-          ) {
+          if (prop === "length" || prop === "byteLength" || prop === "byteOffset" || prop === "buffer" || prop === "BYTES_PER_ELEMENT") {
             return target[prop];
           }
 
@@ -2394,10 +2328,7 @@ function struct(fields, options = {}) {
           return keys;
         },
         getOwnPropertyDescriptor(target, prop) {
-          if (
-            typeof prop === "string" &&
-            (fieldMap.has(prop) || prop === "_buffer" || prop === "toObject")
-          ) {
+          if (typeof prop === "string" && (fieldMap.has(prop) || prop === "_buffer" || prop === "toObject")) {
             return {
               enumerable: prop !== "_buffer" && prop !== "toObject",
               configurable: true,
@@ -2469,47 +2400,28 @@ function struct(fields, options = {}) {
       if (field) {
         // Bit field
         if (field.isBitField) {
-          return _readBitField(
-            buf,
-            field.offset,
-            field.type,
-            field.bitOffset,
-            field.bitSize,
-          );
+          return _readBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize);
         }
 
         // Nested struct (senza dot = ritorna intero oggetto)
         if (field.isNested) {
-          const nestedBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
           // Proxy-based nested instance
           return field.type.create
             ? // Se ha create(), usa quello per creare il proxy
               new Proxy(nestedBuf, {
                 get(target, prop, receiver) {
                   if (prop === "_buffer") return target;
-                  if (prop === "toObject")
-                    return () => field.type.toObject(target);
-                  if (prop === Symbol.toStringTag)
-                    return "NestedStructInstance";
+                  if (prop === "toObject") return () => field.type.toObject(target);
+                  if (prop === Symbol.toStringTag) return "NestedStructInstance";
                   if (prop === Symbol.iterator) return undefined;
                   // Handle Buffer/TypedArray properties
-                  if (
-                    prop === "length" ||
-                    prop === "byteLength" ||
-                    prop === "byteOffset" ||
-                    prop === "buffer" ||
-                    prop === "BYTES_PER_ELEMENT"
-                  ) {
+                  if (prop === "length" || prop === "byteLength" || prop === "byteOffset" || prop === "buffer" || prop === "BYTES_PER_ELEMENT") {
                     return target[prop];
                   }
                   if (typeof prop === "string") {
                     // Check direct fields
-                    const nestedFieldMap = field.type.fields
-                      ? new Map(field.type.fields.map((f) => [f.name, f]))
-                      : new Map();
+                    const nestedFieldMap = field.type.fields ? new Map(field.type.fields.map((f) => [f.name, f])) : new Map();
                     if (nestedFieldMap.has(prop)) {
                       return field.type.get(target, prop);
                     }
@@ -2528,9 +2440,7 @@ function struct(fields, options = {}) {
                 },
                 set(target, prop, value, receiver) {
                   if (typeof prop === "string") {
-                    const nestedFieldMap = field.type.fields
-                      ? new Map(field.type.fields.map((f) => [f.name, f]))
-                      : new Map();
+                    const nestedFieldMap = field.type.fields ? new Map(field.type.fields.map((f) => [f.name, f])) : new Map();
                     if (nestedFieldMap.has(prop)) {
                       field.type.set(target, prop, value);
                       return true;
@@ -2550,8 +2460,7 @@ function struct(fields, options = {}) {
                 has(target, prop) {
                   if (prop === "_buffer" || prop === "toObject") return true;
                   if (typeof prop === "string" && field.type.fields) {
-                    if (field.type.fields.some((f) => f.name === prop))
-                      return true;
+                    if (field.type.fields.some((f) => f.name === prop)) return true;
                   }
                   return Reflect.has(target, prop);
                 },
@@ -2559,11 +2468,7 @@ function struct(fields, options = {}) {
                   return (field.type.fields || []).map((f) => f.name);
                 },
                 getOwnPropertyDescriptor(target, prop) {
-                  if (
-                    typeof prop === "string" &&
-                    field.type.fields &&
-                    field.type.fields.some((f) => f.name === prop)
-                  ) {
+                  if (typeof prop === "string" && field.type.fields && field.type.fields.some((f) => f.name === prop)) {
                     return {
                       enumerable: true,
                       configurable: true,
@@ -2578,10 +2483,7 @@ function struct(fields, options = {}) {
 
         // Array field
         if (field.isArray) {
-          const arrayBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const arrayBuf = buf.subarray(field.offset, field.offset + field.size);
           return field.type.wrap(arrayBuf);
         }
 
@@ -2599,9 +2501,7 @@ function struct(fields, options = {}) {
       if (!field) {
         for (const f of fieldDefs) {
           if (f.isAnonymous && f.type && f.type.fields) {
-            const hasField = f.type.fields.some(
-              (subField) => subField.name === firstPart,
-            );
+            const hasField = f.type.fields.some((subField) => subField.name === firstPart);
             if (hasField) {
               const nestedBuf = buf.subarray(f.offset, f.offset + f.size);
               return f.type.get(nestedBuf, fieldName);
@@ -2650,14 +2550,7 @@ function struct(fields, options = {}) {
       if (field) {
         // Bit field
         if (field.isBitField) {
-          _writeBitField(
-            buf,
-            field.offset,
-            field.type,
-            field.bitOffset,
-            field.bitSize,
-            value,
-          );
+          _writeBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize, value);
           return;
         }
 
@@ -2666,10 +2559,7 @@ function struct(fields, options = {}) {
           if (Buffer.isBuffer(value)) {
             value.copy(buf, field.offset, 0, field.size);
           } else if (typeof value === "object") {
-            const nestedBuf = buf.subarray(
-              field.offset,
-              field.offset + field.size,
-            );
+            const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
             for (const [k, v] of Object.entries(value)) {
               field.type.set(nestedBuf, k, v);
             }
@@ -2682,16 +2572,9 @@ function struct(fields, options = {}) {
           if (Buffer.isBuffer(value)) {
             value.copy(buf, field.offset, 0, field.size);
           } else if (Array.isArray(value)) {
-            const arrayBuf = buf.subarray(
-              field.offset,
-              field.offset + field.size,
-            );
+            const arrayBuf = buf.subarray(field.offset, field.offset + field.size);
             const wrapped = field.type.wrap(arrayBuf);
-            for (
-              let i = 0;
-              i < Math.min(value.length, field.type.length);
-              i++
-            ) {
+            for (let i = 0; i < Math.min(value.length, field.type.length); i++) {
               wrapped[i] = value[i];
             }
           }
@@ -2714,9 +2597,7 @@ function struct(fields, options = {}) {
         for (const f of fieldDefs) {
           if (f.isAnonymous && f.type && f.type.fields) {
             // Verifica se il campo esiste nel tipo anonimo
-            const hasField = f.type.fields.some(
-              (subField) => subField.name === firstPart,
-            );
+            const hasField = f.type.fields.some((subField) => subField.name === firstPart);
             if (hasField) {
               // Scrive nel campo dell'anonymous field
               const nestedBuf = buf.subarray(f.offset, f.offset + f.size);
@@ -2730,14 +2611,7 @@ function struct(fields, options = {}) {
 
       // Bit field
       if (field.isBitField) {
-        _writeBitField(
-          buf,
-          field.offset,
-          field.type,
-          field.bitOffset,
-          field.bitSize,
-          value,
-        );
+        _writeBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize, value);
         return;
       }
 
@@ -2745,20 +2619,14 @@ function struct(fields, options = {}) {
       if (field.isNested) {
         if (parts.length > 1) {
           // Accesso a campo annidato singolo
-          const nestedBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
           field.type.set(nestedBuf, parts.slice(1).join("."), value);
         } else if (Buffer.isBuffer(value)) {
           // Copia buffer
           value.copy(buf, field.offset, 0, field.size);
         } else if (typeof value === "object") {
           // Imposta campi da oggetto
-          const nestedBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
           for (const [k, v] of Object.entries(value)) {
             field.type.set(nestedBuf, k, v);
           }
@@ -2773,10 +2641,7 @@ function struct(fields, options = {}) {
           value.copy(buf, field.offset, 0, field.size);
         } else if (Array.isArray(value)) {
           // Inizializza da array JavaScript
-          const arrayBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const arrayBuf = buf.subarray(field.offset, field.offset + field.size);
           const wrapped = field.type.wrap(arrayBuf);
           for (let i = 0; i < Math.min(value.length, field.type.length); i++) {
             wrapped[i] = value[i];
@@ -2819,18 +2684,9 @@ function struct(fields, options = {}) {
       // Leggi tutti i campi in una volta (eager approach)
       for (const field of fieldDefs) {
         if (field.isBitField) {
-          result[field.name] = _readBitField(
-            buf,
-            field.offset,
-            field.type,
-            field.bitOffset,
-            field.bitSize,
-          );
+          result[field.name] = _readBitField(buf, field.offset, field.type, field.bitOffset, field.bitSize);
         } else if (field.isNested) {
-          const nestedBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const nestedBuf = buf.subarray(field.offset, field.offset + field.size);
           const nestedObj = field.type.toObject(nestedBuf);
           if (field.isAnonymous) {
             // Anonymous fields: promote their fields to parent level
@@ -2839,10 +2695,7 @@ function struct(fields, options = {}) {
             result[field.name] = nestedObj;
           }
         } else if (field.isArray) {
-          const arrayBuf = buf.subarray(
-            field.offset,
-            field.offset + field.size,
-          );
+          const arrayBuf = buf.subarray(field.offset, field.offset + field.size);
           result[field.name] = field.type.wrap(arrayBuf);
         } else {
           // Tipo base - lettura diretta
@@ -2863,8 +2716,7 @@ function struct(fields, options = {}) {
       // O(1) lookup con Map
       const field = fieldMap.get(fieldName);
       if (!field) throw new Error(`Unknown field: ${fieldName}`);
-      if (!field.isNested)
-        throw new Error(`Field ${fieldName} is not a nested struct`);
+      if (!field.isNested) throw new Error(`Field ${fieldName} is not a nested struct`);
       return buf.subarray(field.offset, field.offset + field.size);
     },
   };
@@ -2876,10 +2728,7 @@ function struct(fields, options = {}) {
     structDef._cppStructType = cppStructType;
   } catch (e) {
     // Se fallisce, continua senza C++ (fallback a JS)
-    console.warn(
-      "Failed to create C++ StructType, using JavaScript fallback:",
-      e.message,
-    );
+    console.warn("Failed to create C++ StructType, using JavaScript fallback:", e.message);
   }
 
   // fromObject: write plain object values into buffer
@@ -3140,10 +2989,7 @@ class c_wchar extends SimpleCData {
 class c_void_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "pointer";
-  static _reader = (buf, off) =>
-    native.POINTER_SIZE === 8
-      ? buf.readBigUInt64LE(off)
-      : BigInt(buf.readUInt32LE(off));
+  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
   static _writer = (buf, off, val) => {
     // Accept Buffers (pointer to memory) and struct proxies with _buffer
     if (Buffer.isBuffer(val)) {
@@ -3153,12 +2999,7 @@ class c_void_p extends SimpleCData {
       else buf.writeUInt32LE(Number(v), off);
       return;
     }
-    if (
-      val &&
-      typeof val === "object" &&
-      val._buffer &&
-      Buffer.isBuffer(val._buffer)
-    ) {
+    if (val && typeof val === "object" && val._buffer && Buffer.isBuffer(val._buffer)) {
       const addr = addressOf(val._buffer);
       const v = typeof addr === "bigint" ? addr : BigInt(addr || 0);
       if (native.POINTER_SIZE === 8) buf.writeBigUInt64LE(v, off);
@@ -3179,10 +3020,7 @@ class c_void_p extends SimpleCData {
 class c_size_t extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "size_t";
-  static _reader = (buf, off) =>
-    native.POINTER_SIZE === 8
-      ? buf.readBigUInt64LE(off)
-      : BigInt(buf.readUInt32LE(off));
+  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
   static _writer = (buf, off, val) => {
     const v = typeof val === "bigint" ? val : BigInt(val || 0);
     if (native.POINTER_SIZE === 8) {
@@ -3202,27 +3040,15 @@ const _longSize = native.sizeof ? native.sizeof("long") : 4;
 class c_long extends SimpleCData {
   static _size = _longSize;
   static _type = "long";
-  static _reader =
-    _longSize === 8
-      ? (buf, off) => buf.readBigInt64LE(off)
-      : (buf, off) => buf.readInt32LE(off);
-  static _writer =
-    _longSize === 8
-      ? (buf, off, val) => buf.writeBigInt64LE(BigInt(val), off)
-      : (buf, off, val) => buf.writeInt32LE(val, off);
+  static _reader = _longSize === 8 ? (buf, off) => buf.readBigInt64LE(off) : (buf, off) => buf.readInt32LE(off);
+  static _writer = _longSize === 8 ? (buf, off, val) => buf.writeBigInt64LE(BigInt(val), off) : (buf, off, val) => buf.writeInt32LE(val, off);
 }
 
 class c_ulong extends SimpleCData {
   static _size = _longSize;
   static _type = "ulong";
-  static _reader =
-    _longSize === 8
-      ? (buf, off) => buf.readBigUInt64LE(off)
-      : (buf, off) => buf.readUInt32LE(off);
-  static _writer =
-    _longSize === 8
-      ? (buf, off, val) => buf.writeBigUInt64LE(BigInt(val), off)
-      : (buf, off, val) => buf.writeUInt32LE(val, off);
+  static _reader = _longSize === 8 ? (buf, off) => buf.readBigUInt64LE(off) : (buf, off) => buf.readUInt32LE(off);
+  static _writer = _longSize === 8 ? (buf, off, val) => buf.writeBigUInt64LE(BigInt(val), off) : (buf, off, val) => buf.writeUInt32LE(val, off);
 }
 
 // ============================================================================
@@ -3232,10 +3058,7 @@ class c_ulong extends SimpleCData {
 class c_char_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "char_p";
-  static _reader = (buf, off) =>
-    native.POINTER_SIZE === 8
-      ? buf.readBigUInt64LE(off)
-      : BigInt(buf.readUInt32LE(off));
+  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
   static _writer = (buf, off, val) => {
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
@@ -3259,10 +3082,7 @@ class c_char_p extends SimpleCData {
 class c_wchar_p extends SimpleCData {
   static _size = native.POINTER_SIZE;
   static _type = "wchar_p";
-  static _reader = (buf, off) =>
-    native.POINTER_SIZE === 8
-      ? buf.readBigUInt64LE(off)
-      : BigInt(buf.readUInt32LE(off));
+  static _reader = (buf, off) => (native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off)));
   static _writer = (buf, off, val) => {
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
@@ -3319,9 +3139,7 @@ function create_string_buffer(init) {
     buf[init.length] = 0; // null terminator
     return buf;
   }
-  throw new TypeError(
-    "create_string_buffer requires number, string, or Buffer",
-  );
+  throw new TypeError("create_string_buffer requires number, string, or Buffer");
 }
 
 /**