xm-netcdf-loader 1.0.2 → 1.0.4

package/dist/wasm/wasm-module.js

@@ -1,1502 +0,0 @@
-// WASM module loading and wrapping functionality
-import { NC_CONSTANTS, DATA_TYPE_SIZE } from './constants.js';
-const NC_MAX_NAME = 256;
-const NC_MAX_DIMS = 1024;
-const NC_MAX_VARS = 8192;
-function stridedLength(count) {
-    return count.reduce((acc, c) => acc * c, 1);
-}
-// Helper: validates that the total byte allocation won't overflow a WASM32 uint32.
-// Throws a RangeError if the allocation would be unsafe.
-function safeByteLength(totalLength, elementSize) {
-    const byteLength = totalLength * elementSize;
-    if (byteLength > 0xFFFFFFFF) {
-        throw new RangeError(`Allocation size ${byteLength} exceeds WASM32 heap limit (0xFFFFFFFF). ` +
-            `Requested ${totalLength} elements of ${elementSize} bytes each.`);
-    }
-    return byteLength;
-}
-export class WasmModuleLoader {
-    static async loadModule(options = {}) {
-        try {
-            if (typeof window === 'undefined') {
-                throw new Error('NetCDF4-WASM only works in browser environments.');
-            }
-            // Dynamically import the generated netcdf4-wasm.js module
-            const netcdf4Module = await import('./netcdf4-wasm.js');
-            const createNetCDF4Module = netcdf4Module.default;
-            // Use the imported module factory
-            const rawModule = await createNetCDF4Module({
-                locateFile: (file) => {
-                    if (file.endsWith('.wasm')) {
-                        return options.wasmPath || './netcdf4-wasm.wasm';
-                    }
-                    return file;
-                }
-            });
-            // Wrap the module with high-level functions
-            return WasmModuleLoader.wrapModule(rawModule);
-        }
-        catch (error) {
-            throw new Error(`Failed to load NetCDF4 WASM module: ${error}`);
-        }
-    }
-    static wrapModule(module) {
-        // Create wrappers for NetCDF functions
-        // https://docs.unidata.ucar.edu/netcdf-c/current/group__variables.html#details
-        const nc_open_wrapper = module.cwrap('nc_open_wrapper', 'number', ['string', 'number', 'number']);
-        const nc_close_wrapper = module.cwrap('nc_close_wrapper', 'number', ['number']);
-        const nc_create_wrapper = module.cwrap('nc_create_wrapper', 'number', ['string', 'number', 'number']);
-        const nc_def_dim_wrapper = module.cwrap('nc_def_dim_wrapper', 'number', ['number', 'string', 'number', 'number']);
-        const nc_def_var_wrapper = module.cwrap('nc_def_var_wrapper', 'number', ['number', 'string', 'number', 'number', 'number', 'number']);
-        const nc_put_var_double_wrapper = module.cwrap('nc_put_var_double_wrapper', 'number', ['number', 'number', 'number']);
-        // const nc_get_var_double_wrapper = module.cwrap('nc_get_var_double_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_enddef_wrapper = module.cwrap('nc_enddef_wrapper', 'number', ['number']);
-        // Dimension inquiry wrappers
-        const nc_inq_ndims_wrapper = module.cwrap('nc_inq_ndims_wrapper', 'number', ['number', 'number']);
-        const nc_inq_unlimdim_wrapper = module.cwrap('nc_inq_unlimdim_wrapper', 'number', ['number', 'number']);
-        const nc_inq_dimids_wrapper = module.cwrap('nc_inq_dimids_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        const nc_inq_dim_wrapper = module.cwrap('nc_inq_dim_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        const nc_inq_dimid_wrapper = module.cwrap('nc_inq_dimid_wrapper', 'number', ['number', 'string', 'number']);
-        const nc_inq_dimlen_wrapper = module.cwrap('nc_inq_dimlen_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_dimname_wrapper = module.cwrap('nc_inq_dimname_wrapper', 'number', ['number', 'number', 'number']);
-        // Variable inquiry wrappers
-        const nc_inq_nvars_wrapper = module.cwrap('nc_inq_nvars_wrapper', 'number', ['number', 'number']);
-        const nc_inq_varids_wrapper = module.cwrap('nc_inq_varids_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_varid_wrapper = module.cwrap('nc_inq_varid_wrapper', 'number', ['number', 'string', 'number']);
-        const nc_inq_var_wrapper = module.cwrap('nc_inq_var_wrapper', 'number', [
-            'number', 'number', // ncid, varid
-            'number', // name pointer
-            'number', 'number', 'number', 'number' // typep, ndimsp, dimidsp, nattsp
-        ]);
-        // Variable inquiry wrappers
-        const nc_inq_varname_wrapper = module.cwrap('nc_inq_varname_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_vartype_wrapper = module.cwrap('nc_inq_vartype_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_varndims_wrapper = module.cwrap('nc_inq_varndims_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_vardimid_wrapper = module.cwrap('nc_inq_vardimid_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_varnatts_wrapper = module.cwrap('nc_inq_varnatts_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_var_chunking_wrapper = module.cwrap('nc_inq_var_chunking_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        // Attribute inquiry wrappers
-        const nc_inq_natts_wrapper = module.cwrap('nc_inq_natts_wrapper', 'number', ['number', 'number']);
-        const nc_inq_att_wrapper = module.cwrap('nc_inq_att_wrapper', 'number', ['number', 'number', 'string', 'number', 'number']);
-        const nc_inq_attid_wrapper = module.cwrap('nc_inq_attid_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_inq_attname_wrapper = module.cwrap('nc_inq_attname_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        const nc_inq_atttype_wrapper = module.cwrap('nc_inq_atttype_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_inq_attlen_wrapper = module.cwrap('nc_inq_attlen_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // Attribute getters
-        const nc_get_att_text_wrapper = module.cwrap('nc_get_att_text_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_short_wrapper = module.cwrap('nc_get_att_short_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_int_wrapper = module.cwrap('nc_get_att_int_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_float_wrapper = module.cwrap('nc_get_att_float_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_double_wrapper = module.cwrap('nc_get_att_double_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_longlong_wrapper = module.cwrap('nc_get_att_longlong_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_get_att_string_wrapper = module.cwrap('nc_get_att_string_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_free_string_wrapper = module.cwrap('nc_free_string_wrapper', 'number', ['number', 'number']);
-        const nc_get_att_schar_wrapper = module.cwrap('nc_get_att_schar_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // 8-bit unsigned
-        const nc_get_att_uchar_wrapper = module.cwrap('nc_get_att_uchar_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // 16-bit unsigned
-        const nc_get_att_ushort_wrapper = module.cwrap('nc_get_att_ushort_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // 32-bit unsigned
-        const nc_get_att_uint_wrapper = module.cwrap('nc_get_att_uint_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // 64-bit unsigned
-        const nc_get_att_ulonglong_wrapper = module.cwrap('nc_get_att_ulonglong_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        // Variable getters
-        const nc_get_vara_short_wrapper = module.cwrap('nc_get_vara_short_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_int_wrapper = module.cwrap('nc_get_vara_int_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_float_wrapper = module.cwrap('nc_get_vara_float_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_double_wrapper = module.cwrap('nc_get_vara_double_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_longlong_wrapper = module.cwrap('nc_get_vara_longlong_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_schar_wrapper = module.cwrap('nc_get_vara_schar_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_uchar_wrapper = module.cwrap('nc_get_vara_uchar_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_ushort_wrapper = module.cwrap('nc_get_vara_ushort_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_uint_wrapper = module.cwrap('nc_get_vara_uint_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_ulonglong_wrapper = module.cwrap('nc_get_vara_ulonglong_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_vara_string_wrapper = module.cwrap('nc_get_vara_string_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_get_var_text_wrapper = module.cwrap('nc_get_var_text_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_short_wrapper = module.cwrap('nc_get_var_short_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_int_wrapper = module.cwrap('nc_get_var_int_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_longlong_wrapper = module.cwrap('nc_get_var_longlong_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_float_wrapper = module.cwrap('nc_get_var_float_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_double_wrapper = module.cwrap('nc_get_var_double_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_schar_wrapper = module.cwrap('nc_get_var_schar_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_uchar_wrapper = module.cwrap('nc_get_var_uchar_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_ushort_wrapper = module.cwrap('nc_get_var_ushort_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_uint_wrapper = module.cwrap('nc_get_var_uint_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_ulonglong_wrapper = module.cwrap('nc_get_var_ulonglong_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_var_string_wrapper = module.cwrap('nc_get_var_string_wrapper', 'number', ['number', 'number', 'number']);
-        // Stride inquiry wrappers
-        const nc_get_vars_schar_wrapper = module.cwrap('nc_get_vars_schar_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_uchar_wrapper = module.cwrap('nc_get_vars_uchar_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_short_wrapper = module.cwrap('nc_get_vars_short_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_ushort_wrapper = module.cwrap('nc_get_vars_ushort_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_int_wrapper = module.cwrap('nc_get_vars_int_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_uint_wrapper = module.cwrap('nc_get_vars_uint_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_float_wrapper = module.cwrap('nc_get_vars_float_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_double_wrapper = module.cwrap('nc_get_vars_double_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_longlong_wrapper = module.cwrap('nc_get_vars_longlong_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_ulonglong_wrapper = module.cwrap('nc_get_vars_ulonglong_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_string_wrapper = module.cwrap('nc_get_vars_string_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_wrapper = module.cwrap('nc_get_vars_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_get_vars_text_wrapper = module.cwrap('nc_get_vars_text_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        // const nc_get_vars_as_type_wrapper   = module.cwrap('nc_get_vars_as_type_wrapper', 'number', ['number','number','number','number','number','number','number']);
-        // Group inquiry wrappers
-        const nc_inq_grps_wrapper = module.cwrap('nc_inq_grps_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_grp_ncid_wrapper = module.cwrap('nc_inq_grp_ncid_wrapper', 'number', ['number', 'string', 'number']);
-        const nc_inq_grpname_wrapper = module.cwrap('nc_inq_grpname_wrapper', 'number', ['number', 'number']);
-        const nc_inq_grp_parent_wrapper = module.cwrap('nc_inq_grp_parent_wrapper', 'number', ['number', 'number']);
-        const nc_inq_grp_full_ncid_wrapper = module.cwrap('nc_inq_grp_full_ncid_wrapper', 'number', ['number', 'string', 'number']);
-        const nc_inq_grpname_full_wrapper = module.cwrap('nc_inq_grpname_full_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_grpname_len_wrapper = module.cwrap('nc_inq_grpname_len_wrapper', 'number', ['number', 'number']);
-        // enum wrappers
-        const nc_inq_typeids_wrapper = module.cwrap('nc_inq_typeids_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_inq_type_wrapper = module.cwrap('nc_inq_type_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        const nc_inq_user_type_wrapper = module.cwrap('nc_inq_user_type_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_def_enum_wrapper = module.cwrap('nc_def_enum_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_insert_enum_wrapper = module.cwrap('nc_insert_enum_wrapper', 'number', ['number', 'number', 'string', 'number']);
-        const nc_inq_enum_wrapper = module.cwrap('nc_inq_enum_wrapper', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const nc_inq_enum_member_wrapper = module.cwrap('nc_inq_enum_member_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        const nc_inq_enum_ident_wrapper = module.cwrap('nc_inq_enum_ident_wrapper', 'number', ['number', 'number', 'number', 'number']);
-        // generic type inquiry wrapper
-        const nc_get_var_wrapper = module.cwrap('nc_get_var_wrapper', 'number', ['number', 'number', 'number']);
-        const nc_get_vara_wrapper = module.cwrap('nc_get_vara_wrapper', 'number', ['number', 'number', 'number', 'number', 'number']);
-        return {
-            ...module,
-            nc_open: (path, mode) => {
-                const ncidPtr = module._malloc(4);
-                const result = nc_open_wrapper(path, mode, ncidPtr);
-                const ncid = module.getValue(ncidPtr, 'i32');
-                module._free(ncidPtr);
-                return { result, ncid };
-            },
-            nc_close: (ncid) => {
-                return nc_close_wrapper(ncid);
-            },
-            nc_create: (path, mode) => {
-                const ncidPtr = module._malloc(4);
-                const result = nc_create_wrapper(path, mode, ncidPtr);
-                const ncid = module.getValue(ncidPtr, 'i32');
-                module._free(ncidPtr);
-                return { result, ncid };
-            },
-            // ---- Dimension Inquiry ----//
-            nc_inq_ndims: (ncid) => {
-                const ndimsPtr = module._malloc(4);
-                const result = nc_inq_ndims_wrapper(ncid, ndimsPtr);
-                const ndims = result === NC_CONSTANTS.NC_NOERR ? module.getValue(ndimsPtr, 'i32') : undefined;
-                module._free(ndimsPtr);
-                return { result, ndims };
-            },
-            nc_inq_unlimdim: (ncid) => {
-                const unlimdimidPtr = module._malloc(4);
-                const result = nc_inq_unlimdim_wrapper(ncid, unlimdimidPtr);
-                const unlimdimid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(unlimdimidPtr, 'i32') : undefined;
-                module._free(unlimdimidPtr);
-                return { result, unlimdimid };
-            },
-            nc_inq_dimids: (ncid, include_parents = 0) => {
-                const ndimsPtr = module._malloc(4);
-                const dimidsPtr = module._malloc(NC_MAX_DIMS * 4);
-                const result = nc_inq_dimids_wrapper(ncid, ndimsPtr, dimidsPtr, include_parents);
-                let ndims, dimids;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    ndims = module.getValue(ndimsPtr, 'i32');
-                    dimids = Int32Array.from({ length: ndims }, (_, i) => module.getValue(dimidsPtr + (i * 4), 'i32'));
-                }
-                module._free(ndimsPtr);
-                module._free(dimidsPtr);
-                return { result, ndims, dimids };
-            },
-            nc_inq_dim: (ncid, dimid) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                // In Emscripten wasm32 builds, size_t is 32-bit.
-                // (If we ever build wasm64, this will need revisiting.)
-                const lenPtr = module._malloc(4);
-                const result = nc_inq_dim_wrapper(ncid, dimid, namePtr, lenPtr);
-                let name, len;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    len = module.getValue(lenPtr, 'i32') >>> 0;
-                }
-                module._free(namePtr);
-                module._free(lenPtr);
-                return { result, name, len };
-            },
-            nc_inq_dimid: (ncid, name) => {
-                const dimidPtr = module._malloc(4);
-                const result = nc_inq_dimid_wrapper(ncid, name, dimidPtr);
-                const dimid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(dimidPtr, 'i32') : undefined;
-                module._free(dimidPtr);
-                return { result, dimid };
-            },
-            nc_inq_dimlen: (ncid, dimid) => {
-                // In Emscripten wasm32 builds, size_t is 32-bit.
-                // Allocate 4 bytes and read as unsigned i32 to avoid garbage high bits.
-                const lenPtr = module._malloc(4);
-                const result = nc_inq_dimlen_wrapper(ncid, dimid, lenPtr);
-                let len;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    len = module.getValue(lenPtr, 'i32') >>> 0;
-                }
-                module._free(lenPtr);
-                return { result, len };
-            },
-            nc_inq_dimname: (ncid, dimid) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                module.HEAPU8.fill(0, namePtr, namePtr + NC_MAX_NAME + 1);
-                const result = nc_inq_dimname_wrapper(ncid, dimid, namePtr);
-                const name = result === NC_CONSTANTS.NC_NOERR ? module.UTF8ToString(namePtr) : undefined;
-                module._free(namePtr);
-                return { result, name };
-            },
-            //---- Variable inquiry functions ----//
-            nc_inq_nvars: (ncid) => {
-                const nvarsPtr = module._malloc(4);
-                const result = nc_inq_nvars_wrapper(ncid, nvarsPtr);
-                const nvars = result === NC_CONSTANTS.NC_NOERR ? module.getValue(nvarsPtr, 'i32') : undefined;
-                module._free(nvarsPtr);
-                return { result, nvars };
-            },
-            nc_inq_varids: (ncid) => {
-                const nvarsPtr = module._malloc(4);
-                const varidsPtr = module._malloc(NC_MAX_VARS * 4);
-                const result = nc_inq_varids_wrapper(ncid, nvarsPtr, varidsPtr);
-                let nvars, varids;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    nvars = module.getValue(nvarsPtr, 'i32');
-                    varids = Int32Array.from({ length: nvars }, (_, i) => module.getValue(varidsPtr + (i * 4), 'i32'));
-                }
-                module._free(nvarsPtr);
-                module._free(varidsPtr);
-                return { result, nvars, varids };
-            },
-            nc_inq_varid: (ncid, name) => {
-                const varidPtr = module._malloc(4);
-                const result = nc_inq_varid_wrapper(ncid, name, varidPtr);
-                const varid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(varidPtr, 'i32') : undefined;
-                module._free(varidPtr);
-                return { result, varid };
-            },
-            nc_inq_var: (ncid, varid) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                const typePtr = module._malloc(4);
-                const ndimsPtr = module._malloc(4);
-                const dimidsPtr = module._malloc(NC_MAX_DIMS * 4);
-                const nattsPtr = module._malloc(4);
-                const result = nc_inq_var_wrapper(ncid, varid, namePtr, typePtr, ndimsPtr, dimidsPtr, nattsPtr);
-                let name, type, ndims, dimids, natts;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    type = module.getValue(typePtr, 'i32');
-                    ndims = module.getValue(ndimsPtr, 'i32');
-                    natts = module.getValue(nattsPtr, 'i32');
-                    dimids = Int32Array.from({ length: ndims }, (_, i) => module.getValue(dimidsPtr + (i * 4), 'i32'));
-                }
-                module._free(namePtr);
-                module._free(typePtr);
-                module._free(ndimsPtr);
-                module._free(dimidsPtr);
-                module._free(nattsPtr);
-                return { result, name, type, ndims, dimids, natts };
-            },
-            nc_inq_varname: (ncid, varid) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                const result = nc_inq_varname_wrapper(ncid, varid, namePtr);
-                const name = result === NC_CONSTANTS.NC_NOERR ? module.UTF8ToString(namePtr) : undefined;
-                module._free(namePtr);
-                return { result, name };
-            },
-            nc_inq_vartype: (ncid, varid) => {
-                const typePtr = module._malloc(4);
-                const result = nc_inq_vartype_wrapper(ncid, varid, typePtr);
-                const type = result === NC_CONSTANTS.NC_NOERR ? module.getValue(typePtr, 'i32') : undefined;
-                module._free(typePtr);
-                return { result, type };
-            },
-            nc_inq_varndims: (ncid, varid) => {
-                const ndimsPtr = module._malloc(4);
-                const result = nc_inq_varndims_wrapper(ncid, varid, ndimsPtr);
-                const ndims = result === NC_CONSTANTS.NC_NOERR ? module.getValue(ndimsPtr, 'i32') : undefined;
-                module._free(ndimsPtr);
-                return { result, ndims };
-            },
-            nc_inq_vardimid: (ncid, varid) => {
-                const ndimsPtr = module._malloc(4);
-                const dimidsPtr = module._malloc(NC_MAX_DIMS * 4);
-                const result = nc_inq_vardimid_wrapper(ncid, varid, dimidsPtr); // Note: this wrapper doesn't return ndims first
-                // nc_inq_vardimid writes directly into dimids array; we need ndims separately or assume max
-                // Better: always call nc_inq_varndims first in practice, or use nc_inq_var
-                // For standalone use, we'll read up to NC_MAX_DIMS
-                let dimids;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    // You may want to get ndims first via nc_inq_varndims for exact length
-                    dimids = Int32Array.from(new Int32Array(module.HEAP32.buffer, dimidsPtr, NC_MAX_DIMS));
-                    // Trim trailing -1 or invalid values if needed
-                }
-                module._free(ndimsPtr);
-                module._free(dimidsPtr);
-                return { result, dimids };
-            },
-            nc_inq_varnatts: (ncid, varid) => {
-                const nattsPtr = module._malloc(4);
-                const result = nc_inq_varnatts_wrapper(ncid, varid, nattsPtr);
-                const natts = result === NC_CONSTANTS.NC_NOERR ? module.getValue(nattsPtr, 'i32') : undefined;
-                module._free(nattsPtr);
-                return { result, natts };
-            },
-            nc_inq_var_chunking: (ncid, varid) => {
-                const chunkingPtr = module._malloc(4);
-                const chunkSizesPtr = module._malloc(NC_MAX_DIMS * 4); // assuming size_t is 8 bytes
-                const result = nc_inq_var_chunking_wrapper(ncid, varid, chunkingPtr, chunkSizesPtr);
-                let chunking, chunkSizes;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    chunking = module.getValue(chunkingPtr, 'i32');
-                    // First, get the number of dimensions for this variable
-                    const ndimsPtr = module._malloc(4);
-                    const inqResult = nc_inq_varndims_wrapper(ncid, varid, ndimsPtr);
-                    let ndims = NC_MAX_DIMS; // default fallback
-                    if (inqResult === NC_CONSTANTS.NC_NOERR) {
-                        ndims = module.getValue(ndimsPtr, 'i32');
-                    }
-                    module._free(ndimsPtr);
-                    // Only read the actual number of dimensions
-                    chunkSizes = new Array(ndims);
-                    for (let i = 0; i < ndims; i++) {
-                        chunkSizes[i] = module.getValue(chunkSizesPtr + i * 4, 'i32');
-                    }
-                }
-                module._free(chunkingPtr);
-                module._free(chunkSizesPtr);
-                return { result, chunking, chunkSizes };
-            },
-            //---- Attribute inquiry functions ----//
-            nc_inq_natts: (ncid) => {
-                const nattsPtr = module._malloc(4);
-                const result = nc_inq_natts_wrapper(ncid, nattsPtr);
-                const natts = result === NC_CONSTANTS.NC_NOERR ? module.getValue(nattsPtr, 'i32') : undefined;
-                module._free(nattsPtr);
-                return { result, natts };
-            },
-            nc_inq_att: (ncid, varid, name) => {
-                const typePtr = module._malloc(4);
-                const lenPtr = module._malloc(8);
-                const result = nc_inq_att_wrapper(ncid, varid, name, typePtr, lenPtr);
-                let type, len;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    type = module.getValue(typePtr, 'i32');
-                    len = module.getValue(lenPtr, 'i32');
-                }
-                module._free(typePtr);
-                module._free(lenPtr);
-                return { result, type, len };
-            },
-            nc_inq_attid: (ncid, varid, name) => {
-                const attnumPtr = module._malloc(4);
-                const result = nc_inq_attid_wrapper(ncid, varid, name, attnumPtr);
-                const attnum = result === NC_CONSTANTS.NC_NOERR ? module.getValue(attnumPtr, 'i32') : undefined;
-                module._free(attnumPtr);
-                return { result, attnum };
-            },
-            nc_inq_attname: (ncid, varid, attnum) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                const result = nc_inq_attname_wrapper(ncid, varid, attnum, namePtr);
-                const name = result === NC_CONSTANTS.NC_NOERR ? module.UTF8ToString(namePtr) : undefined;
-                module._free(namePtr);
-                return { result, name };
-            },
-            nc_inq_atttype: (ncid, varid, name) => {
-                const typePtr = module._malloc(4);
-                const result = nc_inq_atttype_wrapper(ncid, varid, name, typePtr);
-                const type = result === NC_CONSTANTS.NC_NOERR ? module.getValue(typePtr, 'i32') : undefined;
-                module._free(typePtr);
-                return { result, type };
-            },
-            nc_inq_attlen: (ncid, varid, name) => {
-                const lenPtr = module._malloc(8);
-                const result = nc_inq_attlen_wrapper(ncid, varid, name, lenPtr);
-                const len = result === NC_CONSTANTS.NC_NOERR ? module.getValue(lenPtr, 'i64') : undefined;
-                module._free(lenPtr);
-                return { result, len };
-            },
-            //---- Attribute Getters ----//
-            nc_get_att_text: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length + 1);
-                const result = nc_get_att_text_wrapper(ncid, varid, name, dataPtr);
-                module.setValue(dataPtr + length, 0, 'i8'); // Add null terminator so it doesn't read too far
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? module.UTF8ToString(dataPtr)
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_short: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 2);
-                const result = nc_get_att_short_wrapper(ncid, varid, name, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from({ length }, (_, i) => module.getValue(dataPtr + i * 2, 'i16'))
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_int: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_att_int_wrapper(ncid, varid, name, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from({ length }, (_, i) => module.getValue(dataPtr + i * 4, 'i32'))
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_float: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_att_float_wrapper(ncid, varid, name, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from({ length }, (_, i) => module.getValue(dataPtr + i * 4, 'float'))
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_double: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_att_double_wrapper(ncid, varid, name, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from({ length }, (_, i) => module.getValue(dataPtr + i * 8, 'double'))
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_longlong: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_att_longlong_wrapper(ncid, varid, name, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from({ length }, (_, i) => BigInt(module.getValue(dataPtr + i * 8, 'i64')))
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            //---- Variable Getters ----//
-            nc_get_vara_short: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 2);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_short_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int16Array(module.HEAP16.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_int: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 4);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_int_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int32Array(module.HEAP32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_float: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 4);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_float_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Float32Array(module.HEAPF32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_double: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 8);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_double_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Float64Array(module.HEAPF64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_longlong: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 8);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_longlong_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new BigInt64Array(module.HEAP64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_schar: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 1);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_schar_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int8Array(module.HEAP8.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_uchar: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 1);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_uchar_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint8Array(module.HEAPU8.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_ushort: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 2);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_ushort_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint16Array(module.HEAPU16.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_uint: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 4);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_uint_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint32Array(module.HEAPU32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_ulonglong: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 8);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_ulonglong_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new BigUint64Array(module.HEAP64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            nc_get_vara_string: (ncid, varid, start, count) => {
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * 4);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_string_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = [];
-                    for (let i = 0; i < totalLength; i++) {
-                        const strPtr = module.getValue(dataPtr + i * 4, '*');
-                        data.push(module.UTF8ToString(strPtr));
-                    }
-                }
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            //---- Full Variable Getters ----//
-            nc_get_var_text: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length);
-                const result = nc_get_var_text_wrapper(ncid, varid, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? [new TextDecoder().decode(module.HEAPU8.subarray(dataPtr, dataPtr + length)).replace(/\0/g, '')]
-                    : undefined;
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_short: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 2);
-                const result = nc_get_var_short_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    // Create a view of the heap and copy it into a new Int16Array
-                    data = new Int16Array(module.HEAP16.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_int: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_var_int_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Int32Array(module.HEAP32.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_float: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_var_float_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Float32Array(module.HEAPF32.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_longlong: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_var_longlong_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    // BigInt64Array is used for i64 (long long)
-                    data = new BigInt64Array(module.HEAP64.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_schar: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 1);
-                const result = nc_get_var_schar_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Int8Array(module.HEAP8.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_uchar: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 1);
-                const result = nc_get_var_uchar_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint8Array(module.HEAPU8.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_ushort: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 2);
-                const result = nc_get_var_ushort_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint16Array(module.HEAPU16.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_uint: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_var_uint_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint32Array(module.HEAPU32.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_ulonglong: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_var_ulonglong_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new BigUint64Array(module.HEAP64.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_var_string: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_var_string_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = [];
-                    for (let i = 0; i < length; i++) {
-                        const strPtr = module.getValue(dataPtr + i * 4, '*');
-                        data.push(module.UTF8ToString(strPtr));
-                    }
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_def_dim: (ncid, name, len) => {
-                const dimidPtr = module._malloc(4);
-                const result = nc_def_dim_wrapper(ncid, name, len, dimidPtr);
-                const dimid = module.getValue(dimidPtr, 'i32');
-                module._free(dimidPtr);
-                return { result, dimid };
-            },
-            nc_def_var: (ncid, name, xtype, ndims, dimids) => {
-                const varidPtr = module._malloc(4);
-                const dimidsPtr = module._malloc(dimids.length * 4);
-                for (let i = 0; i < dimids.length; i++) {
-                    module.setValue(dimidsPtr + i * 4, dimids[i], 'i32');
-                }
-                const result = nc_def_var_wrapper(ncid, name, xtype, ndims, dimidsPtr, varidPtr);
-                const varid = module.getValue(varidPtr, 'i32');
-                module._free(varidPtr);
-                module._free(dimidsPtr);
-                return { result, varid };
-            },
-            nc_put_var_double: (ncid, varid, data) => {
-                const dataPtr = module._malloc(data.length * 8);
-                module.HEAPF64.set(data, dataPtr / 8);
-                const result = nc_put_var_double_wrapper(ncid, varid, dataPtr);
-                module._free(dataPtr);
-                return result;
-            },
-            nc_get_var_double: (ncid, varid, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_var_double_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Float64Array(module.HEAPF64.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_enddef: (ncid) => {
-                return nc_enddef_wrapper(ncid);
-            },
-            //---- Group Functions ----//
-            nc_inq_grps: (ncid) => {
-                const numgrpsPtr = module._malloc(4);
-                const grpidsPtr = module._malloc(NC_MAX_VARS * 4); // reuse NC_MAX_VARS as max groups
-                const result = nc_inq_grps_wrapper(ncid, numgrpsPtr, grpidsPtr);
-                let numgrps, grpids;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    numgrps = module.getValue(numgrpsPtr, 'i32');
-                    grpids = Int32Array.from({ length: numgrps }, (_, i) => module.getValue(grpidsPtr + (i * 4), 'i32'));
-                }
-                module._free(numgrpsPtr);
-                module._free(grpidsPtr);
-                return { result, numgrps, grpids };
-            },
-            nc_inq_grp_ncid: (ncid, grp_name) => {
-                const grp_ncidPtr = module._malloc(4);
-                const result = nc_inq_grp_ncid_wrapper(ncid, grp_name, grp_ncidPtr);
-                const grp_ncid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(grp_ncidPtr, 'i32') : undefined;
-                module._free(grp_ncidPtr);
-                return { result, grp_ncid };
-            },
-            nc_inq_grpname: (ncid) => {
-                const namePtr = module._malloc(NC_MAX_NAME + 1);
-                const result = nc_inq_grpname_wrapper(ncid, namePtr);
-                const name = result === NC_CONSTANTS.NC_NOERR ? module.UTF8ToString(namePtr) : undefined;
-                module._free(namePtr);
-                return { result, name };
-            },
-            nc_inq_grp_parent: (ncid) => {
-                const parent_ncidPtr = module._malloc(4);
-                const result = nc_inq_grp_parent_wrapper(ncid, parent_ncidPtr);
-                const parent_ncid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(parent_ncidPtr, 'i32') : undefined;
-                module._free(parent_ncidPtr);
-                return { result, parent_ncid };
-            },
-            nc_inq_grp_full_ncid: (ncid, full_name) => {
-                const grp_ncidPtr = module._malloc(4);
-                const result = nc_inq_grp_full_ncid_wrapper(ncid, full_name, grp_ncidPtr);
-                const grp_ncid = result === NC_CONSTANTS.NC_NOERR ? module.getValue(grp_ncidPtr, 'i32') : undefined;
-                module._free(grp_ncidPtr);
-                return { result, grp_ncid };
-            },
-            nc_inq_grpname_full: (ncid) => {
-                const maxLen = 1024; // NC_MAX_NAME * path depth estimate
-                const lenpPtr = module._malloc(8); // size_t
-                const namePtr = module._malloc(maxLen);
-                const result = nc_inq_grpname_full_wrapper(ncid, lenpPtr, namePtr);
-                const full_name = result === NC_CONSTANTS.NC_NOERR ? module.UTF8ToString(namePtr) : undefined;
-                module._free(lenpPtr);
-                module._free(namePtr);
-                return { result, full_name };
-            },
-            nc_inq_grpname_len: (ncid) => {
-                const lenpPtr = module._malloc(8); // size_t
-                const result = nc_inq_grpname_len_wrapper(ncid, lenpPtr);
-                const lenp = result === NC_CONSTANTS.NC_NOERR ? module.getValue(lenpPtr, 'i64') : undefined;
-                module._free(lenpPtr);
-                return { result, lenp };
-            },
-            nc_get_att_string: (ncid, varid, name, length) => {
-                // allocate space for char*
-                const ptrArray = module._malloc(length * 4); // pointer array (32bit in wasm)
-                const result = nc_get_att_string_wrapper(ncid, varid, name, ptrArray);
-                if (result !== NC_CONSTANTS.NC_NOERR) {
-                    module._free(ptrArray);
-                    return { result, data: undefined };
-                }
-                const data = [];
-                for (let i = 0; i < length; i++) {
-                    const strPtr = module.getValue(ptrArray + i * 4, '*');
-                    data.push(module.UTF8ToString(strPtr));
-                }
-                // free strings allocated by netcdf
-                nc_free_string_wrapper(length, ptrArray);
-                return { result, data };
-            },
-            nc_get_att_uchar: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length);
-                const result = nc_get_att_uchar_wrapper(ncid, varid, name, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint8Array(module.HEAPU8.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_att_schar: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length);
-                const result = nc_get_att_schar_wrapper(ncid, varid, name, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Int8Array(module.HEAP8.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            // 16-bit unsigned (NC_USHORT)
-            nc_get_att_ushort: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 2);
-                const result = nc_get_att_ushort_wrapper(ncid, varid, name, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint16Array(module.HEAPU16.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            // 32-bit unsigned (NC_UINT)
-            nc_get_att_uint: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 4);
-                const result = nc_get_att_uint_wrapper(ncid, varid, name, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new Uint32Array(module.HEAPU32.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            // 64-bit unsigned (NC_UINT64 / NC_ULONGLONG)
-            nc_get_att_ulonglong: (ncid, varid, name, length) => {
-                const dataPtr = module._malloc(length * 8);
-                const result = nc_get_att_ulonglong_wrapper(ncid, varid, name, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = new BigUint64Array(module.HEAPU64.buffer, dataPtr, length).slice();
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            // Enum Type Functions
-            nc_inq_typeids: (ncid, maxTypeIds) => {
-                const ntypesPtr = module._malloc(4);
-                const typeidsPtr = module._malloc(maxTypeIds * 4);
-                const result = nc_inq_typeids_wrapper(ncid, ntypesPtr, typeidsPtr);
-                let ntypes;
-                let typeids;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    ntypes = module.getValue(ntypesPtr, 'i32');
-                    typeids = [];
-                    for (let i = 0; i < ntypes; i++) {
-                        typeids.push(module.getValue(typeidsPtr + i * 4, 'i32'));
-                    }
-                }
-                module._free(ntypesPtr);
-                module._free(typeidsPtr);
-                return { result, ntypes, typeids };
-            },
-            nc_inq_type: (ncid, xtype) => {
-                const namePtr = module._malloc(NC_CONSTANTS.NC_MAX_NAME + 1);
-                const sizePtr = module._malloc(8);
-                const result = nc_inq_type_wrapper(ncid, xtype, namePtr, sizePtr);
-                let name;
-                let size;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    size = Number(module.getValue(sizePtr, 'i64'));
-                }
-                module._free(namePtr);
-                module._free(sizePtr);
-                return { result, name, size };
-            },
-            nc_inq_user_type: (ncid, xtype) => {
-                const namePtr = module._malloc(NC_CONSTANTS.NC_MAX_NAME + 1);
-                const sizePtr = module._malloc(8);
-                const baseTypePtr = module._malloc(4);
-                const nfieldsPtr = module._malloc(8);
-                const classPtr = module._malloc(4);
-                const result = nc_inq_user_type_wrapper(ncid, xtype, namePtr, sizePtr, baseTypePtr, nfieldsPtr, classPtr);
-                let name;
-                let size;
-                let baseType;
-                let nfields;
-                let typeClass;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    size = Number(module.getValue(sizePtr, 'i64'));
-                    baseType = module.getValue(baseTypePtr, 'i32');
-                    nfields = Number(module.getValue(nfieldsPtr, 'i64'));
-                    typeClass = module.getValue(classPtr, 'i32');
-                }
-                module._free(namePtr);
-                module._free(sizePtr);
-                module._free(baseTypePtr);
-                module._free(nfieldsPtr);
-                module._free(classPtr);
-                return { result, name, size, baseType, nfields, typeClass };
-            },
-            nc_def_enum: (ncid, baseTypeId, name) => {
-                const typeidPtr = module._malloc(4);
-                const result = nc_def_enum_wrapper(ncid, baseTypeId, name, typeidPtr);
-                let typeid;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    typeid = module.getValue(typeidPtr, 'i32');
-                }
-                module._free(typeidPtr);
-                return { result, typeid };
-            },
-            nc_insert_enum: (ncid, xtype, name, value) => {
-                const valuePtr = module._malloc(8); // Always allocate 8 bytes (max needed)
-                if (typeof value === 'bigint') {
-                    // Write bigint as 64-bit integer
-                    const i64Array = new BigInt64Array(module.HEAP8.buffer, valuePtr, 1);
-                    i64Array[0] = value;
-                }
-                else {
-                    // Write number as 32-bit integer (works for byte, short, int, uint)
-                    module.setValue(valuePtr, value, 'i32');
-                }
-                const result = nc_insert_enum_wrapper(ncid, xtype, name, valuePtr);
-                module._free(valuePtr);
-                return { result };
-            },
-            nc_inq_enum: (ncid, xtype) => {
-                const namePtr = module._malloc(NC_CONSTANTS.NC_MAX_NAME + 1);
-                const baseTypePtr = module._malloc(4);
-                const baseSizePtr = module._malloc(8); // size_t can be 8 bytes
-                const numMembersPtr = module._malloc(8); // size_t can be 8 bytes
-                const result = nc_inq_enum_wrapper(ncid, xtype, namePtr, baseTypePtr, baseSizePtr, numMembersPtr);
-                let name;
-                let baseType;
-                let baseSize;
-                let numMembers;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    baseType = module.getValue(baseTypePtr, 'i32');
-                    // Try reading as 32-bit size_t first
-                    baseSize = Number(module.getValue(baseSizePtr, 'i32'));
-                    numMembers = Number(module.getValue(numMembersPtr, 'i32'));
-                }
-                module._free(namePtr);
-                module._free(baseTypePtr);
-                module._free(baseSizePtr);
-                module._free(numMembersPtr);
-                return { result, name, baseType, baseSize, numMembers };
-            },
-            nc_inq_enum_member: (ncid, xtype, idx, baseType) => {
-                const namePtr = module._malloc(NC_CONSTANTS.NC_MAX_NAME + 1);
-                const valuePtr = module._malloc(8);
-                const result = nc_inq_enum_member_wrapper(ncid, xtype, idx, namePtr, valuePtr);
-                let name;
-                let value;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    name = module.UTF8ToString(namePtr);
-                    // Read value based on base type
-                    switch (baseType) {
-                        case NC_CONSTANTS.NC_BYTE:
-                            value = module.getValue(valuePtr, 'i8');
-                            break;
-                        case NC_CONSTANTS.NC_UBYTE:
-                            value = module.getValue(valuePtr, 'i8') & 0xFF;
-                            break;
-                        case NC_CONSTANTS.NC_SHORT:
-                            value = module.getValue(valuePtr, 'i16');
-                            break;
-                        case NC_CONSTANTS.NC_USHORT:
-                            value = module.getValue(valuePtr, 'i16') & 0xFFFF;
-                            break;
-                        case NC_CONSTANTS.NC_INT:
-                            value = module.getValue(valuePtr, 'i32');
-                            break;
-                        case NC_CONSTANTS.NC_UINT:
-                            value = module.getValue(valuePtr, 'i32') >>> 0;
-                            break;
-                        case NC_CONSTANTS.NC_INT64:
-                            value = module.getValue(valuePtr, 'i64');
-                            break;
-                        case NC_CONSTANTS.NC_UINT64:
-                            value = module.getValue(valuePtr, 'i64');
-                            break;
-                        default:
-                            value = module.getValue(valuePtr, 'i32');
-                    }
-                }
-                module._free(namePtr);
-                module._free(valuePtr);
-                return { result, name, value };
-            },
-            nc_inq_enum_ident: (ncid, xtype, value) => {
-                const identPtr = module._malloc(NC_CONSTANTS.NC_MAX_NAME + 1);
-                const numValue = typeof value === 'bigint' ? Number(value) : value;
-                const result = nc_inq_enum_ident_wrapper(ncid, xtype, numValue, identPtr);
-                let identifier;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    identifier = module.UTF8ToString(identPtr);
-                }
-                module._free(identPtr);
-                return { result, identifier };
-            },
-            // generic nc_get_var function to module
-            nc_get_var_generic: (ncid, varid, length, nctype) => {
-                const elementSize = DATA_TYPE_SIZE[nctype];
-                const dataPtr = module._malloc(length * elementSize);
-                const result = nc_get_var_wrapper(ncid, varid, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    switch (nctype) {
-                        case NC_CONSTANTS.NC_BYTE:
-                            data = new Int8Array(module.HEAP8.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UBYTE:
-                            data = new Uint8Array(module.HEAPU8.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_SHORT:
-                            data = new Int16Array(module.HEAP16.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_USHORT:
-                            data = new Uint16Array(module.HEAPU16.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT:
-                            data = new Int32Array(module.HEAP32.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT:
-                            data = new Uint32Array(module.HEAPU32.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT64:
-                            data = new BigInt64Array(module.HEAP64.buffer, dataPtr, length).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT64:
-                            data = new BigUint64Array(module.HEAPU64.buffer, dataPtr, length).slice();
-                            break;
-                    }
-                }
-                module._free(dataPtr);
-                return { result, data };
-            },
-            nc_get_vara_generic: (ncid, varid, start, count, nctype) => {
-                const elementSize = DATA_TYPE_SIZE[nctype];
-                const totalLength = count.reduce((a, b) => a * b, 1);
-                const dataPtr = module._malloc(totalLength * elementSize);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                start.forEach((val, i) => module.setValue(startPtr + i * 4, val, 'i32'));
-                count.forEach((val, i) => module.setValue(countPtr + i * 4, val, 'i32'));
-                const result = nc_get_vara_wrapper(ncid, varid, startPtr, countPtr, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    switch (nctype) {
-                        case NC_CONSTANTS.NC_BYTE:
-                            data = new Int8Array(module.HEAP8.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UBYTE:
-                            data = new Uint8Array(module.HEAPU8.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_SHORT:
-                            data = new Int16Array(module.HEAP16.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_USHORT:
-                            data = new Uint16Array(module.HEAPU16.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT:
-                            data = new Int32Array(module.HEAP32.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT:
-                            data = new Uint32Array(module.HEAPU32.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT64:
-                            data = new BigInt64Array(module.HEAP64.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT64:
-                            data = new BigUint64Array(module.HEAPU64.buffer, dataPtr, totalLength).slice();
-                            break;
-                    }
-                }
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                return { result, data };
-            },
-            // start/count/stride → i32 / 4 bytes per element (size_t and ptrdiff_t are 4 bytes in wasm32)
-            nc_get_vars_schar: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 1));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_schar_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int8Array(module.HEAP8.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_uchar: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 1));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_uchar_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint8Array(module.HEAPU8.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_short: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 2));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_short_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int16Array(module.HEAP16.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_ushort: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 2));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_ushort_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint16Array(module.HEAPU16.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_int: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 4));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_int_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Int32Array(module.HEAP32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_uint: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 4));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_uint_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Uint32Array(module.HEAPU32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_float: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 4));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_float_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Float32Array(module.HEAPF32.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_double: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 8));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_double_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new Float64Array(module.HEAPF64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_longlong: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 8));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_longlong_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new BigInt64Array(module.HEAP64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_ulonglong: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 8));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_ulonglong_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? new BigUint64Array(module.HEAPU64.buffer, dataPtr, totalLength).slice()
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_string: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                // validate allocation size won't overflow WASM32 uint32.
-                // char* pointers are 4 bytes in wasm32, so elementSize = 4.
-                const dataPtr = module._malloc(safeByteLength(totalLength, 4));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_string_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    data = [];
-                    for (let i = 0; i < totalLength; i++) {
-                        const strPtr = module.getValue(dataPtr + i * 4, '*');
-                        data.push(module.UTF8ToString(strPtr));
-                    }
-                    // free the individual strings allocated by NetCDF-C before
-                    // freeing the pointer array. nc_free_string_wrapper handles both.
-                    nc_free_string_wrapper(totalLength, dataPtr);
-                }
-                else {
-                    module._free(dataPtr);
-                }
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_generic: (ncid, varid, start, count, stride, nctype) => {
-                const elementSize = DATA_TYPE_SIZE[nctype];
-                const totalLength = stridedLength(count);
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                if (nctype === NC_CONSTANTS.NC_STRING) {
-                    // validate allocation size won't overflow WASM32 uint32.
-                    const dataPtr = module._malloc(safeByteLength(totalLength, 4));
-                    const result = nc_get_vars_string_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                    let data;
-                    if (result === NC_CONSTANTS.NC_NOERR) {
-                        data = [];
-                        for (let i = 0; i < totalLength; i++) {
-                            const strPtr = module.getValue(dataPtr + i * 4, '*');
-                            data.push(module.UTF8ToString(strPtr));
-                        }
-                        // free the individual strings allocated by NetCDF-C before
-                        // freeing the pointer array. nc_free_string_wrapper handles both.
-                        nc_free_string_wrapper(totalLength, dataPtr);
-                    }
-                    else {
-                        module._free(dataPtr);
-                    }
-                    module._free(startPtr);
-                    module._free(countPtr);
-                    module._free(stridePtr);
-                    return { result, data };
-                }
-                //  validate allocation size won't overflow WASM32 uint32.
-                const dataPtr = module._malloc(safeByteLength(totalLength, elementSize));
-                const result = nc_get_vars_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                let data;
-                if (result === NC_CONSTANTS.NC_NOERR) {
-                    switch (nctype) {
-                        case NC_CONSTANTS.NC_BYTE:
-                            data = new Int8Array(module.HEAP8.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UBYTE:
-                            data = new Uint8Array(module.HEAPU8.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_SHORT:
-                            data = new Int16Array(module.HEAP16.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_USHORT:
-                            data = new Uint16Array(module.HEAPU16.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT:
-                            data = new Int32Array(module.HEAP32.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT:
-                            data = new Uint32Array(module.HEAPU32.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_FLOAT:
-                            data = new Float32Array(module.HEAPF32.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_DOUBLE:
-                            data = new Float64Array(module.HEAPF64.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_INT64:
-                            data = new BigInt64Array(module.HEAP64.buffer, dataPtr, totalLength).slice();
-                            break;
-                        case NC_CONSTANTS.NC_UINT64:
-                            data = new BigUint64Array(module.HEAPU64.buffer, dataPtr, totalLength).slice();
-                            break;
-                    }
-                }
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-            nc_get_vars_text: (ncid, varid, start, count, stride) => {
-                const totalLength = stridedLength(count);
-                const dataPtr = module._malloc(safeByteLength(totalLength, 1));
-                const startPtr = module._malloc(start.length * 4);
-                const countPtr = module._malloc(count.length * 4);
-                const stridePtr = module._malloc(stride.length * 4);
-                start.forEach((v, i) => module.setValue(startPtr + i * 4, v, 'i32'));
-                count.forEach((v, i) => module.setValue(countPtr + i * 4, v, 'i32'));
-                stride.forEach((v, i) => module.setValue(stridePtr + i * 4, v, 'i32'));
-                const result = nc_get_vars_text_wrapper(ncid, varid, startPtr, countPtr, stridePtr, dataPtr);
-                const data = result === NC_CONSTANTS.NC_NOERR
-                    ? Array.from(new TextDecoder().decode(module.HEAPU8.subarray(dataPtr, dataPtr + totalLength)), char => char === '\0' ? '' : char)
-                    : undefined;
-                module._free(dataPtr);
-                module._free(startPtr);
-                module._free(countPtr);
-                module._free(stridePtr);
-                return { result, data };
-            },
-        };
-    }
-}
-//# sourceMappingURL=wasm-module.js.map