node-ctypes 0.1.3 → 0.1.5

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() {
@@ -380,8 +454,23 @@ function cstring(str) {
  * @returns {Buffer} Buffer con stringa wide
  */
 function wstring(str) {
-  // Converti stringa JS a UTF-16LE (che è come wchar_t su Windows)
-  const buf = Buffer.from(str + "\0", "utf16le");
+  // Crea un buffer contenente la stringa wide null-terminata
+  // Su Windows wchar_t è 2 bytes (UTF-16LE), su Unix è 4 bytes (UTF-32LE)
+  const wcharSize = native.WCHAR_SIZE;
+  if (wcharSize === 2) {
+    return Buffer.from(str + "\0", "utf16le");
+  }
+
+  // Costruisci manualmente UTF-32LE
+  const codePoints = [];
+  for (const ch of str) {
+    codePoints.push(ch.codePointAt(0));
+  }
+  const buf = Buffer.alloc((codePoints.length + 1) * 4);
+  for (let i = 0; i < codePoints.length; i++) {
+    buf.writeUInt32LE(codePoints[i], i * 4);
+  }
+  // terminatore 0 già inizializzato
   return buf;
 }
 
@@ -547,12 +636,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 +653,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 +764,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 {
@@ -767,12 +840,28 @@ function union(fields) {
     let size, alignment;
     let fieldDef = { name, type, offset: 0 };
 
-    // Nested struct
+    // Nested struct (object form)
     if (_isStruct(type)) {
       size = type.size;
       alignment = type.alignment;
       fieldDef.isNested = true;
     }
+    // Struct class (declarata come `class X extends Structure`)
+    else if (typeof type === "function" && type.prototype instanceof Structure) {
+      const nested = type._structDef || type._buildStruct();
+      size = nested.size;
+      alignment = nested.alignment;
+      fieldDef.type = nested;
+      fieldDef.isNested = true;
+    }
+    // Union class (declarata come `class X extends Union`)
+    else if (typeof type === "function" && type.prototype instanceof Union) {
+      const nested = type._unionDef || type._buildUnion();
+      size = nested.size;
+      alignment = nested.alignment;
+      fieldDef.type = nested;
+      fieldDef.isNested = true;
+    }
     // Array type
     else if (_isArrayType(type)) {
       size = type.getSize();
@@ -794,9 +883,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 +941,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 +976,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 +1006,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 +1020,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 +1034,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 +1049,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 +1066,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 +1092,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 +1101,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 +1114,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 +1132,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 +1166,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 +1184,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 +1254,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 +1332,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 +1351,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 +1481,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
@@ -1543,26 +1551,31 @@ class Union extends Structure {
  * console.log(arr[2]);  // 42
  */
 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)",
-    );
+  // Validate elementType: accept SimpleCData classes, Structure/Union classes,
+  // or native CType-like objects.
+  const isSimple = typeof elementType === "function" && elementType._isSimpleCData;
+  const isStruct = typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union);
+  const isNativeTypeObj = typeof elementType === "object" && elementType !== null && (typeof elementType.getSize === "function" || elementType.size !== undefined);
+  if (!isSimple && !isStruct && !isNativeTypeObj) {
+    throw new TypeError("array elementType must be a SimpleCData class or a Structure/Union class");
   }
 
-  const elementSize = elementType._size;
+  const elementSize = sizeof(elementType);
   let nativeArray;
-  if (typeof elementType === "object") {
+  if (isNativeTypeObj) {
     nativeArray = new ArrayType(elementType, count);
   } else {
-    // For strings, create a mock
+    // Provide a small JS-side shim implementing the minimal ArrayType API
     nativeArray = {
       getSize: () => count * elementSize,
       getLength: () => count,
-      getAlignment: () => elementSize, // Approximation
+      getAlignment: () => elementSize,
       create: (values) => {
-        // Already handled in JS
-        throw new Error("Should not be called");
+        // JS create is implemented below; this should not be invoked by JS code
+        const size = count * elementSize;
+        const buffer = alloc(size);
+        buffer.fill(0);
+        return buffer;
       },
     };
   }
@@ -1592,7 +1605,13 @@ function array(elementType, count) {
         if (prop === Symbol.iterator) {
           return function* () {
             for (let i = 0; i < count; i++) {
-              yield elementType._reader(target, i * elementSize);
+              const off = i * elementSize;
+              // If elementType is a struct/union class, return an instance bound to the slice
+              if (typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union)) {
+                yield new elementType(target.subarray(off, off + elementSize));
+              } else {
+                yield readValue(target, elementType, off);
+              }
             }
           };
         }
@@ -1610,7 +1629,11 @@ function array(elementType, count) {
         const index = Number(prop);
         if (Number.isInteger(index) && !isNaN(index)) {
           if (index >= 0 && index < count) {
-            return readValue(target, elementType, index * elementSize);
+            const off = index * elementSize;
+            if (typeof elementType === "function" && (elementType.prototype instanceof Structure || elementType.prototype instanceof Union)) {
+              return new elementType(target.subarray(off, off + elementSize));
+            }
+            return readValue(target, elementType, off);
           }
           // Indice numerico fuori bounds -> undefined (comportamento JavaScript)
           return undefined;
@@ -1666,12 +1689,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 +1804,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 +1903,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 +1918,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 +2007,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 +2045,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 +2081,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
@@ -2122,6 +2114,66 @@ function struct(fields, options = {}) {
         maxAlignment = alignment;
       }
     }
+    // Caso 2a: Struct class (declarata come `class X extends Structure`)
+    else if (typeof type === "function" && type.prototype instanceof Structure) {
+      // Reset bit field state
+      currentBitFieldBase = null;
+      currentBitOffset = 0;
+
+      const nestedStruct = type._structDef || type._buildStruct();
+      const size = nestedStruct.size;
+      const alignment = packed ? 1 : nestedStruct.alignment;
+
+      // Applica padding per allineamento
+      if (!packed && totalSize % alignment !== 0) {
+        totalSize += alignment - (totalSize % alignment);
+      }
+
+      fieldDef = {
+        name,
+        type: nestedStruct,
+        offset: totalSize,
+        size,
+        alignment,
+        isNested: true,
+      };
+
+      totalSize += size;
+
+      if (alignment > maxAlignment) {
+        maxAlignment = alignment;
+      }
+    }
+    // Caso 2b: Union class (declarata come `class X extends Union`)
+    else if (typeof type === "function" && type.prototype instanceof Union) {
+      // Reset bit field state
+      currentBitFieldBase = null;
+      currentBitOffset = 0;
+
+      const nestedUnion = type._unionDef || type._buildUnion();
+      const size = nestedUnion.size;
+      const alignment = packed ? 1 : nestedUnion.alignment;
+
+      // Applica padding per allineamento
+      if (!packed && totalSize % alignment !== 0) {
+        totalSize += alignment - (totalSize % alignment);
+      }
+
+      fieldDef = {
+        name,
+        type: nestedUnion,
+        offset: totalSize,
+        size,
+        alignment,
+        isNested: true,
+      };
+
+      totalSize += size;
+
+      if (alignment > maxAlignment) {
+        maxAlignment = alignment;
+      }
+    }
     // Caso 2: Nested struct
     else if (_isStruct(type)) {
       // Reset bit field state
@@ -2190,9 +2242,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 +2302,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 +2351,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 +2436,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 +2508,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 +2548,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 +2568,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 +2576,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 +2591,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 +2609,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 +2658,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 +2667,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 +2680,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 +2705,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 +2719,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 +2727,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 +2749,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 +2792,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 +2803,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 +2824,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 +2836,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
@@ -3026,7 +2983,10 @@ class c_int32 extends SimpleCData {
   static _size = 4;
   static _type = "int32";
   static _reader = (buf, off) => buf.readInt32LE(off);
-  static _writer = (buf, off, val) => buf.writeInt32LE(val, off);
+  static _writer = (buf, off, val) => {
+    const v = Number(val) | 0; // coerce to signed 32-bit
+    return buf.writeInt32LE(v, off);
+  };
 }
 
 class c_int64 extends SimpleCData {
@@ -3140,10 +3100,11 @@ 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) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return ptr;
+  };
   static _writer = (buf, off, val) => {
     // Accept Buffers (pointer to memory) and struct proxies with _buffer
     if (Buffer.isBuffer(val)) {
@@ -3153,12 +3114,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 +3135,11 @@ 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) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return ptr;
+  };
   static _writer = (buf, off, val) => {
     const v = typeof val === "bigint" ? val : BigInt(val || 0);
     if (native.POINTER_SIZE === 8) {
@@ -3202,27 +3159,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,11 +3177,15 @@ 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) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return readCString(ptr);
+  };
   static _writer = (buf, off, val) => {
+    if (typeof val === "string") {
+      val = cstring(val);
+    }
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
       const v = typeof addr === "bigint" ? addr : BigInt(addr || 0);
@@ -3259,11 +3208,15 @@ 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) => {
+    const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
+    if (!ptr) return null;
+    return readWString(ptr);
+  };
   static _writer = (buf, off, val) => {
+    if (typeof val === "string") {
+      val = wstring(val);
+    }
     if (Buffer.isBuffer(val)) {
       const addr = addressOf(val);
       const v = typeof addr === "bigint" ? addr : BigInt(addr || 0);
@@ -3319,9 +3272,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");
 }
 
 /**