vitest-pool-assemblyscript 0.9.1 → 0.10.1

package/dist/wasm-memory-C8Nkl2Sz.mjs

@@ -0,0 +1,134 @@
+//#region src/util/assemblyscript/binding-helpers.ts
+const STRING_EXTRACT_CHUNK_SIZE = 1024;
+/**
+* Decode an AssemblyScript string from WASM memory, using the length stored at
+* the beginning of the string.
+*
+* This approach is borrowed from AssemblyScript with changes for clarity.
+* AssemblyScript is released under the Apache 2.0 license, included here.
+* 
+* When a string argument crosses the boundary to JS, we get a pointer to the
+* string data in WASM memory. WASM strings store their length in the 4 bytes
+* before the string data pointer so we know how much to read from memory.
+*
+* @param memory - WebAssembly memory instance
+* @param pointer - Pointer to the start of the string
+* @returns Decoded string
+*/
+function liftString(memory, pointer) {
+	if (!pointer) return void 0;
+	const unsigned = pointer >>> 0;
+	const uint32LengthPtr = unsigned - 4 >>> 2;
+	const byteOffsetLength = new Uint32Array(memory.buffer)[uint32LengthPtr];
+	if (byteOffsetLength === 0) return "";
+	const uint16EndPtr = unsigned + byteOffsetLength >>> 1;
+	let uint16StartPtr = unsigned >>> 1;
+	const memoryU16 = new Uint16Array(memory.buffer);
+	let string = "";
+	while (uint16EndPtr - uint16StartPtr > STRING_EXTRACT_CHUNK_SIZE) string += String.fromCharCode(...memoryU16.subarray(uint16StartPtr, uint16StartPtr += STRING_EXTRACT_CHUNK_SIZE));
+	return string + String.fromCharCode(...memoryU16.subarray(uint16StartPtr, uint16EndPtr));
+}
+
+//#endregion
+//#region src/wasm-executor/wasm-memory.ts
+const DEFAULT_MEMORY_REQS = {
+	testMemory: { initialPages: 1 },
+	coverageMemory: { initialPages: 1 }
+};
+const TEST_MEM_KEY = "env.memory";
+const COVERAGE_MEM_KEY = `${"__as_pool_env__"}.${"__coverage_memory"}`;
+/**
+* Create a WebAssembly memory instance
+* Used for imported memory pattern (matches --importMemory flag)
+*/
+function createMemory(initialPages, maximumPages) {
+	return new WebAssembly.Memory({
+		initial: initialPages,
+		maximum: maximumPages
+	});
+}
+/**
+* Decode AssemblyScript abort information
+*
+* Helper for handling abort() calls from AssemblyScript runtime.
+* Decodes the error message and file path from WASM memory.
+*
+* @param memory - WebAssembly memory instance
+* @param msgPtr - Pointer to error message string (or 0 if none)
+* @param filePtr - Pointer to file path string (or 0 if none)
+* @param line - Line number where abort occurred
+* @param column - Column number where abort occurred
+* @returns Decoded message and location (null if no meaningful location info)
+*/
+function decodeAbortInfo(memory, msgPtr, filePtr, line, column) {
+	const errorMsg = liftString(memory, msgPtr) ?? "Unknown error";
+	const filePath = liftString(memory, filePtr);
+	return {
+		message: errorMsg,
+		location: filePath && filePath !== "unknown" && (line !== 0 || column !== 0) ? `${filePath}:${line}:${column}` : null
+	};
+}
+function getWasmMemoryRequirements(u8) {
+	if (u8[0] !== 0 || u8[1] !== 97 || u8[2] !== 115 || u8[3] !== 109) throw new Error("Not a valid WebAssembly binary");
+	const reqs = {
+		testMemory: { ...DEFAULT_MEMORY_REQS.testMemory },
+		coverageMemory: { ...DEFAULT_MEMORY_REQS.coverageMemory }
+	};
+	let offset = 8;
+	const decoder = new TextDecoder("utf-8");
+	function readVarUint() {
+		let result = 0;
+		let shift = 0;
+		while (true) {
+			const byte = u8[offset++];
+			result |= (byte & 127) << shift;
+			if ((byte & 128) === 0) break;
+			shift += 7;
+		}
+		return result;
+	}
+	while (offset < u8.length) {
+		const sectionId = u8[offset++];
+		const sectionLength = readVarUint();
+		const nextSectionOffset = offset + sectionLength;
+		if (sectionId === 2) {
+			const numImports = readVarUint();
+			for (let i = 0; i < numImports; i++) {
+				const modLen = readVarUint();
+				const modName = decoder.decode(u8.subarray(offset, offset + modLen));
+				offset += modLen;
+				const fieldLen = readVarUint();
+				const fieldName = decoder.decode(u8.subarray(offset, offset + fieldLen));
+				offset += fieldLen;
+				const kind = u8[offset++];
+				if (kind === 2) {
+					const flags = u8[offset++];
+					const initialPages = readVarUint();
+					const maximumPages = (flags & 1) === 1 ? readVarUint() : void 0;
+					const key = `${modName}.${fieldName}`;
+					if (key === TEST_MEM_KEY) reqs.testMemory = {
+						initialPages,
+						maximumPages
+					};
+					else if (key === COVERAGE_MEM_KEY) reqs.coverageMemory = {
+						initialPages,
+						maximumPages
+					};
+				} else if (kind === 0) readVarUint();
+				else if (kind === 1) {
+					offset++;
+					const flags = u8[offset++];
+					readVarUint();
+					if (flags & 1) readVarUint();
+				} else if (kind === 3) offset += 2;
+			}
+			return reqs;
+		}
+		offset = nextSectionOffset;
+	}
+	return reqs;
+}
+
+//#endregion
+export { createMemory, decodeAbortInfo, getWasmMemoryRequirements, liftString };
+//# sourceMappingURL=wasm-memory-C8Nkl2Sz.mjs.map

package/dist/wasm-memory-C8Nkl2Sz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-memory-C8Nkl2Sz.mjs","names":[],"sources":["../src/util/assemblyscript/binding-helpers.ts","../src/wasm-executor/wasm-memory.ts"],"sourcesContent":["const STRING_EXTRACT_CHUNK_SIZE = 1024 as const;\n\n/**\n * Decode an AssemblyScript string from WASM memory, using the length stored at\n * the beginning of the string.\n *\n * This approach is borrowed from AssemblyScript with changes for clarity.\n * AssemblyScript is released under the Apache 2.0 license, included here.\n * \n * When a string argument crosses the boundary to JS, we get a pointer to the\n * string data in WASM memory. WASM strings store their length in the 4 bytes\n * before the string data pointer so we know how much to read from memory.\n *\n * @param memory - WebAssembly memory instance\n * @param pointer - Pointer to the start of the string\n * @returns Decoded string\n */\nexport function liftString(\n  memory: WebAssembly.Memory,\n  pointer: number,\n): string | undefined {\n  if (!pointer) return undefined;\n\n  const unsigned = pointer >>> 0;\n  \n  const lengthPtr = unsigned - 4;\n\n  // convert byte-based lengthPtr to uint32-based index for Uint32Array\n  // with: bytes / 4 (=== bytes >>> 2) and read length\n  const uint32LengthPtr = lengthPtr >>> 2;\n  const byteOffsetLength = new Uint32Array(memory.buffer)[uint32LengthPtr];\n\n  if (byteOffsetLength === 0) return '';\n  \n  // calculate end pointer, and convert byte-based start and end pointers\n  // to uint16-based indexes for Uint16Array with: bytes / 2 (=== bytes >>> 1) \n  const uint16EndPtr = (unsigned + byteOffsetLength!) >>> 1;\n  let uint16StartPtr = unsigned >>> 1;\n\n  const memoryU16 = new Uint16Array(memory.buffer);\n  let string = '';\n\n  // extract in 1024-character chunks to avoid hitting spread operator limit\n  while (uint16EndPtr - uint16StartPtr > STRING_EXTRACT_CHUNK_SIZE) {\n    string += String.fromCharCode(\n      ...memoryU16.subarray(uint16StartPtr, uint16StartPtr += STRING_EXTRACT_CHUNK_SIZE)\n    );\n  }\n\n  return string + String.fromCharCode(...memoryU16.subarray(uint16StartPtr, uint16EndPtr));\n}\n","import {\n  AS_POOL_WASM_COVERAGE_MEM_IMPORT_NAME,\n  AS_POOL_WASM_IMPORTS_MODULE_NAME\n} from '../types/constants.js';\nimport type { WASMModuleMemoryRequirements } from '../types/types.js';\nimport { liftString } from '../util/assemblyscript/binding-helpers.js';\n\nconst DEFAULT_MEMORY_REQS: WASMModuleMemoryRequirements = {\n  testMemory: { initialPages: 1 },\n  coverageMemory: { initialPages: 1 }\n} as const;\nconst TEST_MEM_KEY = 'env.memory' as const;\nconst COVERAGE_MEM_KEY = `${AS_POOL_WASM_IMPORTS_MODULE_NAME}.${AS_POOL_WASM_COVERAGE_MEM_IMPORT_NAME}`;\n\n/**\n * Create a WebAssembly memory instance\n * Used for imported memory pattern (matches --importMemory flag)\n */\nexport function createMemory(initialPages: number, maximumPages?: number): WebAssembly.Memory {\n  return new WebAssembly.Memory({ initial: initialPages, maximum: maximumPages });\n}\n\n/**\n * Decode AssemblyScript abort information\n *\n * Helper for handling abort() calls from AssemblyScript runtime.\n * Decodes the error message and file path from WASM memory.\n *\n * @param memory - WebAssembly memory instance\n * @param msgPtr - Pointer to error message string (or 0 if none)\n * @param filePtr - Pointer to file path string (or 0 if none)\n * @param line - Line number where abort occurred\n * @param column - Column number where abort occurred\n * @returns Decoded message and location (null if no meaningful location info)\n */\nexport function decodeAbortInfo(\n  memory: WebAssembly.Memory,\n  msgPtr: number,\n  filePtr: number,\n  line: number,\n  column: number\n): { message: string; location: string | null } {\n  const errorMsg = liftString(memory, msgPtr) ?? 'Unknown error';  \n  const filePath = liftString(memory, filePtr);\n\n  // Only include location if we have meaningful file info (not null/empty and not at 0:0)\n  const hasLocation = filePath && filePath !== 'unknown' && (line !== 0 || column !== 0);\n  const location = hasLocation ? `${filePath}:${line}:${column}` : null;\n\n  return {\n    message: errorMsg,\n    location: location,\n  };\n}\n\nexport function getWasmMemoryRequirements(u8: Uint8Array): WASMModuleMemoryRequirements {\n  if (u8[0] !== 0x00 || u8[1] !== 0x61 || u8[2] !== 0x73 || u8[3] !== 0x6d) {\n    throw new Error(\"Not a valid WebAssembly binary\");\n  }\n\n  const reqs: WASMModuleMemoryRequirements = {\n    testMemory: { ...DEFAULT_MEMORY_REQS.testMemory },\n    coverageMemory: { ...DEFAULT_MEMORY_REQS.coverageMemory }\n  };\n\n  let offset = 8;\n  const decoder = new TextDecoder('utf-8');\n\n  function readVarUint() {\n    let result = 0;\n    let shift = 0;\n    while (true) {\n      const byte = u8[offset++]!;\n      result |= (byte & 0x7f) << shift;\n      if ((byte & 0x80) === 0) break;\n      shift += 7;\n    }\n    return result;\n  }\n\n  while (offset < u8.length) {\n    const sectionId = u8[offset++];\n    const sectionLength = readVarUint();\n    const nextSectionOffset = offset + sectionLength;\n\n    if (sectionId === 2) { // 2 = Import Section\n      const numImports = readVarUint();\n\n      for (let i = 0; i < numImports; i++) {\n        // Extract and decode Module Name\n        const modLen = readVarUint();\n        const modName = decoder.decode(u8.subarray(offset, offset + modLen));\n        offset += modLen;\n\n        // Extract and decode Field/Memory Name\n        const fieldLen = readVarUint();\n        const fieldName = decoder.decode(u8.subarray(offset, offset + fieldLen));\n        offset += fieldLen;\n\n        const kind = u8[offset++];\n        \n        if (kind === 0x02) { // Memory Import\n          const flags = u8[offset++];\n          const initialPages = readVarUint();\n          \n          const hasMaximum = (flags! & 0x01) === 0x01;\n          const maximumPages = hasMaximum ? readVarUint() : undefined;\n          \n          const key = `${modName}.${fieldName}`;\n          if (key === TEST_MEM_KEY) {\n            reqs.testMemory = { initialPages, maximumPages };\n          } else if (key === COVERAGE_MEM_KEY) {\n            reqs.coverageMemory = { initialPages, maximumPages }\n          }\n        } else if (kind === 0x00) { // Function\n          readVarUint();\n        } else if (kind === 0x01) { // Table\n          offset++;\n          const flags = u8[offset++];\n          readVarUint();\n          if (flags! & 1) readVarUint();\n        } else if (kind === 0x03) { // Global\n          offset += 2;\n        }\n      }\n      // We can stop processing once the import section is completely parsed\n      return reqs;\n    }\n    offset = nextSectionOffset;\n  }\n  return reqs; \n}\n"],"mappings":"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"}

package/dist/{worker-rpc-channel-CZZIxtv5.mjs → worker-rpc-channel-CvCrc8aa.mjs}

@@ -22,4 +22,4 @@ function createWorkerRPCChannel(project, collect) {
 
 //#endregion
 export { createWorkerRPCChannel };
-//# sourceMappingURL=worker-rpc-channel-CZZIxtv5.mjs.map
+//# sourceMappingURL=worker-rpc-channel-CvCrc8aa.mjs.map

package/dist/{worker-rpc-channel-CZZIxtv5.mjs.map → worker-rpc-channel-CvCrc8aa.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"worker-rpc-channel-CZZIxtv5.mjs","names":[],"sources":["../src/pool/worker-rpc-channel.ts"],"sourcesContent":["import { MessageChannel } from 'node:worker_threads';\nimport { createBirpc } from 'birpc';\nimport type { RunnerRPC, RuntimeRPC } from 'vitest';\nimport { type TestProject, createMethodsRPC } from 'vitest/node';\n\nimport type { WorkerChannel } from '../types/types.js';\n\n/**\n * Create a MessageChannel with RPC for worker thread communication\n */\nexport function createWorkerRPCChannel(project: TestProject, collect: boolean): WorkerChannel {\n  const channel = new MessageChannel();\n  const workerPort = channel.port1;\n  const poolPort = channel.port2;\n\n  const methods = createMethodsRPC(project, { collect });\n\n  // Create RPC in pool\n  const rpc = createBirpc<RuntimeRPC, RunnerRPC>(\n    methods,\n    {\n      post: (v) => poolPort.postMessage(v),\n      on: (fn) => poolPort.on('message', fn),\n    }\n  );\n\n  return { workerPort, poolPort, rpc };\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,uBAAuB,SAAsB,SAAiC;CAC5F,MAAM,UAAU,IAAI,gBAAgB;CACpC,MAAM,aAAa,QAAQ;CAC3B,MAAM,WAAW,QAAQ;AAazB,QAAO;EAAE;EAAY;EAAU,KARnB,YAHI,iBAAiB,SAAS,EAAE,SAAS,CAAC,EAKpD;GACE,OAAO,MAAM,SAAS,YAAY,EAAE;GACpC,KAAK,OAAO,SAAS,GAAG,WAAW,GAAG;GACvC,CACF;EAEmC"}
+{"version":3,"file":"worker-rpc-channel-CvCrc8aa.mjs","names":[],"sources":["../src/pool/worker-rpc-channel.ts"],"sourcesContent":["import { MessageChannel } from 'node:worker_threads';\nimport { createBirpc } from 'birpc';\nimport type { RunnerRPC, RuntimeRPC } from 'vitest';\nimport { type TestProject, createMethodsRPC } from 'vitest/node';\n\nimport type { WorkerChannel } from '../types/types.js';\n\n/**\n * Create a MessageChannel with RPC for worker thread communication\n */\nexport function createWorkerRPCChannel(project: TestProject, collect: boolean): WorkerChannel {\n  const channel = new MessageChannel();\n  const workerPort = channel.port1;\n  const poolPort = channel.port2;\n\n  const methods = createMethodsRPC(project, { collect });\n\n  // Create RPC in pool\n  const rpc = createBirpc<RuntimeRPC, RunnerRPC>(\n    methods,\n    {\n      post: (v) => poolPort.postMessage(v),\n      on: (fn) => poolPort.on('message', fn),\n    }\n  );\n\n  return { workerPort, poolPort, rpc };\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,uBAAuB,SAAsB,SAAiC;CAC5F,MAAM,UAAU,IAAI,gBAAgB;CACpC,MAAM,aAAa,QAAQ;CAC3B,MAAM,WAAW,QAAQ;AAazB,QAAO;EAAE;EAAY;EAAU,KARnB,YAHI,iBAAiB,SAAS,EAAE,SAAS,CAAC,EAKpD;GACE,OAAO,MAAM,SAAS,YAAY,EAAE;GACpC,KAAK,OAAO,SAAS,GAAG,WAAW,GAAG;GACvC,CACF;EAEmC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-pool-assemblyscript",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "description": "AssemblyScript testing with Vitest - Simple, fast, familiar, AS-native, with full coverage output",
   "author": "Matt Ritter <matthew.d.ritter@gmail.com>",
   "license": "MIT",

package/src/instrumentation/native/addon.cpp

@@ -25,10 +25,10 @@
 using namespace wasm;
 
 // 32
-const uint32_t BYTES_PER_COUNTER = 4;
+const int32_t BYTES_PER_COUNTER = 4;
 
 // 1 page = 64KB / 4bytes (32bits) each = 16384 counters
-const uint32_t COUNTERS_PER_PAGE = 16384;
+const int32_t COUNTERS_PER_PAGE = 16384;
 
 // TODO - pass these through the call stack as params instead
 // for now we don't expect them to  change between different calls
@@ -38,9 +38,9 @@ thread_local std::string LOG_PREFIX = "InstNative";
 
 struct SourceDebugLocation {
   bool exists = false;
-  uint32_t fileIndex = 0;              // Debug location file index
-  uint32_t lineNumber = 0;            // Debug location line number
-  uint32_t columnNumber = 0;          // Debug location column number
+  int32_t fileIndex = 0;              // Debug location file index
+  int32_t lineNumber = 0;            // Debug location line number
+  int32_t columnNumber = 0;          // Debug location column number
 };
 
 /**
@@ -48,12 +48,12 @@ struct SourceDebugLocation {
  */
 struct ExpressionInfo {
   std::string type;                    // Expression type name
-  uint32_t fileIndex;                  // Debug location file index
-  uint32_t lineNumber;                 // Debug location line number
-  uint32_t columnNumber;               // Debug location column number
+  int32_t fileIndex;                  // Debug location file index
+  int32_t lineNumber;                 // Debug location line number
+  int32_t columnNumber;               // Debug location column number
   bool hasDebugLocation;               // Whether debug location exists
   bool isBranch;                       // Whether this is a branch expression
-  uint32_t branchPaths;                // Number of branch paths (if isBranch)
+  int32_t branchPaths;                // Number of branch paths (if isBranch)
 };
 
 /**
@@ -67,7 +67,7 @@ struct BasicBlockInfo {
 // Data structure to collect function info during instrumentation
 struct FunctionInfo {
   std::string name;
-  uint32_t coverageMemoryIndex;
+  int32_t coverageMemoryIndex;
   SourceDebugLocation representativeLocation;
   std::vector<ExpressionInfo> expressions;
   std::vector<BasicBlockInfo> blocks;
@@ -437,12 +437,16 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
     std::string excludedLibraryFilePrefix;
     std::string excludedLibraryFileOverridePrefix = "";
     std::string excludedInternalFunctionSubstring = "";
+    std::string coverageMemoryModule = "";
+    std::string coverageMemoryName = "";
 
     // 1 page = 64KB / 4bytes (32bits) each = 16384 counters
-    uint32_t coverageMemoryPagesMin = 1;
+    int32_t coverageMemoryPagesMin = 1;
     // 4 pages = 256KB / 4bytes (32bits) each = 65536 counters
-    uint32_t coverageMemoryPagesMax = 4;
-    uint32_t maxCounters = coverageMemoryPagesMax * COUNTERS_PER_PAGE;
+    int32_t coverageMemoryPagesMax = -1;
+
+    // computed values
+    int32_t maxCounters = coverageMemoryPagesMax == -1 ? -1 : coverageMemoryPagesMax * COUNTERS_PER_PAGE;
 
     if (options.Has("logPrefix")) {
       Napi::Value logPrefixProp = options.Get("logPrefix");
@@ -467,14 +471,14 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
       if (excludedFilesProperty.IsArray()) {
         const Napi::Array filesArray = excludedFilesProperty.As<Napi::Array>();
 
-        const uint32_t count = filesArray.Length();
+        const int32_t count = filesArray.Length();
         if (DEBUG && count > 0) {
           std::cout << LOG_PREFIX << " - OPTIONS - " << count << " Excluded Files:" << std::endl;
         } else if (DEBUG) {
           std::cout << LOG_PREFIX << " - 0 Excluded Files" << std::endl;
         }
 
-        for (size_t i = 0; i < count; i++) {
+        for (int32_t i = 0; i < count; i++) {
           Napi::Value fileItem = filesArray[i];
           if (fileItem.IsString()) {
             const std::string file = fileItem.As<Napi::String>().Utf8Value();
@@ -526,7 +530,7 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
         coverageMemoryPagesMin = coverageMinProperty.As<Napi::Number>().Int32Value();
         
         if (DEBUG) {
-          const uint32_t minCounters = coverageMemoryPagesMin * COUNTERS_PER_PAGE;
+          const int32_t minCounters = coverageMemoryPagesMin * COUNTERS_PER_PAGE;
           std::cout << LOG_PREFIX << " - OPTIONS - Coverage Memory Pages MIN: " << coverageMemoryPagesMin
                     << " (" << minCounters << " counters)" << std::endl;
         }
@@ -546,6 +550,28 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
       }
     }
 
+    if (options.Has("coverageMemoryModule")) {
+      Napi::Value coverageMemoryModuleProperty = options.Get("coverageMemoryModule");
+      if (coverageMemoryModuleProperty.IsString()) {
+        coverageMemoryModule = coverageMemoryModuleProperty.As<Napi::String>().Utf8Value();
+        
+        if (DEBUG) {
+          std::cout << LOG_PREFIX << " - OPTIONS - Coverage Memory Module: \"" << coverageMemoryModule << "\"" << std::endl;
+        }
+      }
+    }
+    
+    if (options.Has("coverageMemoryName")) {
+      Napi::Value coverageMemoryNameProperty = options.Get("coverageMemoryName");
+      if (coverageMemoryNameProperty.IsString()) {
+        coverageMemoryName = coverageMemoryNameProperty.As<Napi::String>().Utf8Value();
+        
+        if (DEBUG) {
+          std::cout << LOG_PREFIX << " - OPTIONS - Coverage Memory Name: \"" << coverageMemoryName << "\"" << std::endl;
+        }
+      }
+    }
+
     std::vector<char> wasmData(wasmBuf.Data(), wasmBuf.Data() + wasmBuf.Length());
     std::vector<char> sourceMapData(sourceMapBuf.Data(), sourceMapBuf.Data() + sourceMapBuf.Length());
 
@@ -565,22 +591,14 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
 
     // Instrument functions and collect debug info
     Builder builder(module);
-    uint32_t coverageIndex = 0;
+    int32_t coverageIndex = 0;
     std::vector<FunctionInfo> instrumentedFunctions;
 
     // Enable multi-memory feature for coverage memory
     module.features.setMultiMemory(true);
 
-    // Add __coverage_memory import
-    // This is a secondary memory used to store coverage counters
-    Name coverageMemoryName("__coverage_memory");
-    auto coverageMemory = Builder::makeMemory(coverageMemoryName);
-    coverageMemory->module = "__as_pool_env__";
-    coverageMemory->base = "__coverage_memory";
-    coverageMemory->initial = coverageMemoryPagesMin;
-    coverageMemory->max = coverageMemoryPagesMax;
-    coverageMemory->shared = false;
-    module.addMemory(std::move(coverageMemory));
+    // secondary memory import used to store coverage counters
+    const Name coverageMemoryWasmName(coverageMemoryName);
 
     // Create walker for debug info extraction
     DebugInfoWalker walker(&module);
@@ -588,10 +606,10 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
     ModuleUtils::iterDefinedFunctions(module, [&](Function* func) {
       std::string funcName = func->name.toString();
 
-      if (coverageIndex >= maxCounters) {
+      if (maxCounters > 0 && coverageIndex >= maxCounters) {
         if (DEBUG) {
           std::cout << LOG_PREFIX << " - ERROR: Processing function: \"" << funcName << "\""
-                    << " Further instrumentation would exceed max covergare memory size" << std::endl;
+                    << " Further instrumentation would exceed max coverage memory size" << std::endl;
         }
         return;
       }
@@ -658,7 +676,7 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
       //   incremented = counter + 1
       //   i32.store(addr, incremented, __coverage_memory)
 
-      const uint32_t counterAddressVal = coverageIndex * BYTES_PER_COUNTER;
+      const int32_t counterAddressVal = coverageIndex * BYTES_PER_COUNTER;
       Expression* counterAddress = builder.makeConstantExpression(Literal(counterAddressVal));
 
       // Load current counter value
@@ -669,7 +687,7 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
         BYTES_PER_COUNTER,  // align - we should always be aligned
         counterAddress,     // address
         Type::i32,
-        coverageMemoryName
+        coverageMemoryWasmName
       );
 
       // Increment counter
@@ -686,7 +704,7 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
         counterAddress,     // address
         incrementedCounter, // value
         Type::i32,
-        coverageMemoryName
+        coverageMemoryWasmName
       );
 
       // Prepend instrumentation to function body
@@ -701,6 +719,27 @@ Napi::Object InstrumentForCoverage(const Napi::CallbackInfo& info) {
       coverageIndex++;
     });
 
+    int32_t requiredCoverageMemoryPagesMax = std::ceil(coverageIndex / static_cast<double>(COUNTERS_PER_PAGE));
+
+    // Add __coverage_memory import
+    auto coverageMemory = Builder::makeMemory(coverageMemoryWasmName);
+    coverageMemory->module = coverageMemoryModule;
+    coverageMemory->base = coverageMemoryName;
+    coverageMemory->shared = false;
+    coverageMemory->initial = coverageMemoryPagesMin;
+
+    if (coverageMemoryPagesMax <= 0) {
+      coverageMemory->max = requiredCoverageMemoryPagesMax <= 0 ? 1 : requiredCoverageMemoryPagesMax;
+    } else {
+      coverageMemory->max = coverageMemoryPagesMax;
+    }
+
+    if (DEBUG) {
+      std::cout << LOG_PREFIX << " - Coverage memory max pages set to: " << coverageMemory->max << std::endl;
+    }
+    
+    module.addMemory(std::move(coverageMemory));
+
     if (DEBUG) {
       std::cout << LOG_PREFIX << " - Instrumentation complete: " << coverageIndex << " functions instrumented" << std::endl;
     }

package/dist/addon-interface-CYFXMbK7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"addon-interface-CYFXMbK7.mjs","names":[],"sources":["../src/instrumentation/addon-interface.ts"],"sourcesContent":["/**\n * Native addon interface for extracting debug information from WebAssembly binaries\n *\n * This module wraps Binaryen's C++ API to provide expression-level debug locations\n * and basic block information that the JavaScript API doesn't expose.\n *\n * The native addon outputs raw data (0-based columns, relative paths) which this\n * wrapper transforms into the final BinaryDebugInfo format (1-based columns,\n * absolute paths, grouped by file and position).\n */\n\nimport { createRequire } from 'node:module';\nimport { resolve, dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type {\n  NativeAddon,\n  NativeInstrumentationResult,\n  NativeDebugInfoOutput,\n  NativeFunctionDebugInfo,\n  NativeExpressionDebugInfo,\n  NativeSourceLocation,\n  BinaryDebugInfo,\n  FunctionDebugInfo,\n  SourceLocation,\n  ExpressionDebugInfo,\n  InstrumentationResult,\n  NativeInstrumentationOptions,\n  InstrumentationOptions,\n  InstrumentForCoverageFunc,\n} from '../types/types.js';\nimport {\n  POOL_ERROR_NAMES,\n  INTERNAL_PATH_LIB_PREFIX,\n} from '../types/constants.js';\nimport { debug } from '../util/debug.js';\nimport { toForwardSlash } from '../util/path-utils.js';\nimport { createPoolError } from '../util/pool-errors.js';\nimport { getShortFunctionName } from '../wasm-executor/wasm-names.js';\n\n// Load the native addon via node-gyp-build\n// node-gyp-build checks: prebuilds/ first, then build/Release/\n// It searches from the given directory for a package.json to find the package root.\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\nconst rootFromDist = resolve(__dirname, '..');\n// TODO: Verify if this src fallback is still needed — pool always runs from dist/ even locally.\n// If confirmed dead code, remove this and simplify to a single nodeGypBuild call.\nconst rootFromSrc = resolve(__dirname, '../..');\n\nconst require = createRequire(import.meta.url);\nconst nodeGypBuild: (dir: string) => NativeAddon = require('node-gyp-build');\n\nlet addon: NativeAddon;\ntry {\n  addon = nodeGypBuild(rootFromDist);\n} catch {\n  try {\n    addon = nodeGypBuild(rootFromSrc);\n  } catch (err) {\n    throw createPoolError(\n      `vitest-pool-assemblyscript native instrumentation addon not found. Searched from ${rootFromDist} and ${rootFromSrc}. `\n      + `Ensure prebuilds are available or run 'node node_modules/vitest-pool-assemblyscript/scripts/install-native-addon.js'`\n      + ` to compile from source. Original error: ${err instanceof Error ? err.message : String(err)}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n}\n\n/**\n * Convert a raw location (0-indexed columns, path indexes) to\n * processed location (1-indexed columns, absolute path strings)\n *\n * Source map paths vary by import style and project structure:\n * - Relative imports: \"assembly/compare.ts\"\n * - Bare package imports: \"~lib/vitest-pool-assemblyscript/assembly/compare.ts\"\n * - Source outside project root: \"../assembly/compare.ts\" (e.g. test-external importing parent sources)\n *\n * All are normalized to absolute filesystem paths for consistent coverage key matching.\n */\nfunction convertLocation(\n  rawLocation: NativeSourceLocation,\n  debugSourceFiles: string[],\n  projectRoot: string\n): SourceLocation {\n  let filePath = debugSourceFiles[rawLocation.fileIndex];\n\n  if (!filePath) {\n    throw createPoolError(\n      `No debug source file with index: ${rawLocation.fileIndex}}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n\n  // Normalize to absolute path for consistent coverage key matching\n  if (filePath.startsWith(INTERNAL_PATH_LIB_PREFIX)) {\n    // ~lib/vitest-pool-assemblyscript/assembly/X.ts -> projectRoot/assembly/X.ts\n    const relativePart = filePath.slice(INTERNAL_PATH_LIB_PREFIX.length);\n    filePath = toForwardSlash(resolve(projectRoot, 'assembly', relativePart));\n  } else {\n    // Resolve relative path (handles both 'assembly/X.ts' and '../assembly/X.ts')\n    filePath = toForwardSlash(resolve(projectRoot, filePath));\n  }\n\n  return {\n    filePath,\n    line: rawLocation.line,\n    column: rawLocation.column + 1,  // convert from 0-indexed to 1-indexed\n  };\n}\n\n/**\n * Convert a raw expression to processed format\n */\nfunction convertExpression(\n  rawExpr: NativeExpressionDebugInfo,\n  debugSourceFiles: string[],\n  projectRoot: string\n): ExpressionDebugInfo {\n  const converted: ExpressionDebugInfo = {\n    type: rawExpr.type,\n    isBranch: rawExpr.isBranch,\n  };\n\n  if (rawExpr.branchPaths !== undefined) {\n    converted.branchPaths = rawExpr.branchPaths;\n  }\n\n  if (rawExpr.location) {\n    const convertedLocation = convertLocation(rawExpr.location, debugSourceFiles, projectRoot);\n    if (convertedLocation) {\n      converted.location = convertedLocation;\n    }\n  }\n\n  return converted;\n}\n\n/**\n * Generate a position key to identify the SourceLocation uniquely\n * within a file. Does NOT include the file identifier.\n */\nfunction getPositionKey(location: SourceLocation) {\n  return `${location.line}:${location.column}`;\n}\n\n/**\n * Convert a raw function to processed format and compute position key\n * Returns undefined if function has no valid representative location\n */\nfunction convertFunction(\n  rawFunc: NativeFunctionDebugInfo,\n  debugSourceFiles: string[],\n  projectRoot: string\n): { func: FunctionDebugInfo; filePath: string; positionKey: string } | undefined {\n  const representativeLocation = convertLocation(rawFunc.representativeLocation, debugSourceFiles, projectRoot);\n\n  // Convert expressions\n  const expressions: ExpressionDebugInfo[] = [];\n  if (rawFunc.expressions) {\n    for (const expr of rawFunc.expressions) {\n      expressions.push(convertExpression(expr, debugSourceFiles, projectRoot));\n    }\n  }\n\n  const converted: FunctionDebugInfo = {\n    wasmIndex: rawFunc.wasmIndex,\n    name: rawFunc.name,\n    representativeLocation,\n    coverageMemoryIndex: rawFunc.coverageMemoryIndex,\n    expressions,\n    basicBlocks: rawFunc.basicBlocks,\n  };\n\n  const filePath = representativeLocation.filePath;\n  const positionKey = getPositionKey(representativeLocation);\n\n  return { func: converted, filePath, positionKey };\n}\n\n/**\n * Check if two WASM function names are monomorphizations of the same generic function.\n * Generic monomorphizations share the same base name and suffix, differing only in\n * the type parameters inside angle brackets.\n *\n * e.g. \"assembly/compare/closeTo<bool\\2cbool>\" and \"assembly/compare/closeTo<bool\\2cu8>\"\n * e.g. \"assembly/expect/BaseExpectMatcher<bool>#constructor\" and \"assembly/expect/BaseExpectMatcher<i8>#constructor\"\n */\nfunction isGenericMonomorphizationMatch(nameA: string, nameB: string): boolean {\n  const openA = nameA.indexOf('<');\n  const openB = nameB.indexOf('<');\n\n  // Both must contain generic type parameters\n  if (openA === -1 || openB === -1) return false;\n\n  const lastCloseA = nameA.lastIndexOf('>');\n  const lastCloseB = nameB.lastIndexOf('>');\n\n  if (lastCloseA === -1 || lastCloseB === -1) return false;\n\n  // Prefix before '<' must match (includes module path, class, function name)\n  const prefixA = nameA.substring(0, openA);\n  const prefixB = nameB.substring(0, openB);\n  if (prefixA !== prefixB) return false;\n\n  // Suffix after last '>' must match (e.g. \"#constructor\", or empty)\n  const suffixA = nameA.substring(lastCloseA + 1);\n  const suffixB = nameB.substring(lastCloseB + 1);\n  if (suffixA !== suffixB) return false;\n\n  return true;\n}\n\n/**\n * Transform raw native addon output to processed BinaryDebugInfo\n */\nfunction transformDebugInfo(\n  raw: NativeDebugInfoOutput,\n  logPrefix: string,\n  projectRoot: string,\n): BinaryDebugInfo {\n  const functionsByFileAndPosition: Record<string, Record<string, FunctionDebugInfo[]>> = {};\n\n  debug(`${logPrefix} - Converting ${raw.functions.length} functions`);\n\n  let genericCollisionCount = 0;\n  let skippedCount = 0;\n  let instrumentedFunctionCount = 0;\n\n  for (const rawFunc of raw.functions) {\n    const result = convertFunction(rawFunc, raw.debugSourceFiles, projectRoot);\n    if (!result) {\n      debug(`${logPrefix} - WARNING: Skipped function (bad conversion): \"${rawFunc.name}\"`);\n      skippedCount++;\n      continue;\n    }\n\n    const { func, filePath, positionKey } = result;\n\n    // Check for position collisions\n    const existingAtPosition = functionsByFileAndPosition[filePath]?.[positionKey];\n    if (existingAtPosition) {\n      const existingName = existingAtPosition[0]!.name;\n\n      // Only allow collision if both are monomorphizations of the same generic\n      if (isGenericMonomorphizationMatch(existingName, func.name)) {\n        existingAtPosition.push(func);\n        genericCollisionCount++;\n        instrumentedFunctionCount++;\n        debug(\n          `${logPrefix} - Generic monomorphization at ${filePath}:${positionKey}:`\n          + ` \"${getShortFunctionName(func.name)}\" grouped with \"${getShortFunctionName(existingName)}\"`\n        );\n        continue;\n      }\n\n      throw createPoolError(\n        `ERROR - Function Debug Position Collision at ${filePath}:${positionKey}: \"${getShortFunctionName(existingName)}\"`\n        + ` will be replaced by \"${getShortFunctionName(func.name)}\". This is a bug. Please report it at:`\n        + ` https://github.com/themattspiral/vitest-pool-assemblyscript/issues/new`,\n        POOL_ERROR_NAMES.WASMInstrumentationError\n      );\n    }\n\n    instrumentedFunctionCount++;\n\n    // Group by file and position\n    if (!functionsByFileAndPosition[filePath]) {\n      functionsByFileAndPosition[filePath] = {};\n    }\n\n    functionsByFileAndPosition[filePath][positionKey] = [func];\n  }\n\n  debug(\n    `${logPrefix} - BinaryDebugInfo transform complete: ${instrumentedFunctionCount} instrumented functions`\n    + ` (${genericCollisionCount} generic collisions, ${skippedCount} skipped)`\n  );\n\n  return {\n    debugSourceFiles: raw.debugSourceFiles,\n    functionsByFileAndPosition,\n    instrumentedFunctionCount,\n  };\n}\n\n/**\n * Instrument a WASM binary for coverage collection and regenerate source map\n *\n * This function:\n * 1. Adds __coverage_memory import (multi-memory for coverage counters)\n * 2. Injects coverage counter increments at each function entry\n * 3. Regenerates source map with correct offsets after instrumentation\n * 4. Extracts debug info with coverageMemoryIndex assigned\n *\n * @param wasmBuffer - Buffer containing the clean WASM binary\n * @param sourceMapBuffer - Buffer containing the source map JSON\n * @returns Instrumented binary, regenerated source map, and debug info\n *\n * @throws {TypeError} If wasmBuffer or sourceMapBuffer are not Buffers\n * @throws {Error} If WASM binary or source map is invalid\n */\nexport const instrumentForCoverage: InstrumentForCoverageFunc = (\n  wasmBuffer: Buffer,\n  sourceMapBuffer: Buffer,\n  instrumentationOptions: InstrumentationOptions,\n  logModule: string,\n  logLabel: string,\n): InstrumentationResult => {\n  if (!Buffer.isBuffer(wasmBuffer)) {\n    throw createPoolError(\n      'instrumentForCoverage - wasmBuffer must be a Buffer',\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n  if (!Buffer.isBuffer(sourceMapBuffer)) {\n    throw createPoolError(\n      'instrumentForCoverage - sourceMapBuffer must be a Buffer',\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n\n  const interfaceLogPrefix = `[${logModule} Inst] ${logLabel}`;\n  const nativeLogPrefix = `[${logModule} InstNative] ${logLabel}`;\n\n  debug(`${interfaceLogPrefix} - Calling native instrumentForCoverage`);\n  const startTime = performance.now();\n\n  const options: NativeInstrumentationOptions = {\n    coverageMemoryPagesMin: instrumentationOptions.coverageMemoryPagesMin,\n    coverageMemoryPagesMax: instrumentationOptions.coverageMemoryPagesMax,\n    excludedFiles: instrumentationOptions.relativeExcludedFiles,\n    excludedLibraryFilePrefix: instrumentationOptions.excludedLibraryFilePrefix,\n    excludedLibraryFileOverridePrefix: instrumentationOptions.excludedLibraryFileOverridePrefix,\n    excludedInternalFunctionSubstring: instrumentationOptions.excludedInternalFunctionSubstring,\n    debug: instrumentationOptions.debug,\n    logPrefix: nativeLogPrefix\n  };\n  const nativeResult: NativeInstrumentationResult = addon.instrumentForCoverage(wasmBuffer, sourceMapBuffer, options);\n  const addonTime = performance.now();\n  debug(`${interfaceLogPrefix} - TIMING Native addon: ${(addonTime - startTime).toFixed(2)} ms`);\n\n  if (nativeResult.errors?.length) {\n    throw createPoolError(\n      `Errors encountered duriing native instrumentation: ${nativeResult.errors.join('\\n')}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError,\n    );\n  }\n\n  const debugInfo = transformDebugInfo(nativeResult.debugInfo, interfaceLogPrefix, instrumentationOptions.projectRoot);\n  \n  const transformTime = performance.now();\n  debug(`${interfaceLogPrefix} - TIMING DebugInfo Transform: ${(transformTime - addonTime).toFixed(2)} ms`);\n  debug(`${interfaceLogPrefix} - Binary size: ${nativeResult.instrumentedWasm.length} bytes | Source map size: ${nativeResult.sourceMap.length * 2} bytes`);\n\n  return {\n    instrumentedWasm: nativeResult.instrumentedWasm,\n    sourceMap: nativeResult.sourceMap,\n    debugInfo,\n  };\n}\n"],"mappings":"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"}

package/dist/compile-runner-BNFHRGZO.mjs

@@ -1,85 +0,0 @@
-import { INTERNAL_PATH_LIB_PREFIX, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS } from "./constants-DbxJ3hzg.mjs";
-import { createPoolErrorFromAnyError, debug, getTestErrorFromPoolError } from "./debug-DtRAL4rM.mjs";
-import { toForwardSlash } from "./path-utils-t9OzjXYF.mjs";
-import { failFile, getFullTaskHierarchy, prepareFileTaskForCollection } from "./vitest-file-tasks-D8sOClGX.mjs";
-import { getTaskLogLabel, getTaskLogPrefix } from "./vitest-tasks-BZ24sghI.mjs";
-import { executeWASMDiscovery, flushRpcUpdates, reportFileCollected, reportFileError, reportFileQueued, reportUserConsoleLogs } from "./load-user-imports-Bx5ZlhSm.mjs";
-import { compileAssemblyScript } from "./compiler-Dqs-qd3I.mjs";
-import { basename, relative } from "node:path";
-
-//#region src/pool-thread/runner/compile-runner.ts
-/**
-* Worker thread test runner logic for AssemblyScript Pool
-*/
-let threadCompilationCount = 0;
-async function runCompileAndDiscover(file, logModule, rpc, poolOptions, projectRoot, collectCoverage, relativeUserCoverageExclusions, threadImports, diffOptions, testNamePattern, allowOnly) {
-	const base = basename(file.filepath);
-	const fileLogPrefix = getTaskLogPrefix(logModule, base, file);
-	const fileLogLabel = getTaskLogLabel(base, file);
-	debug(`${fileLogPrefix} - Beginning runCompileAndDiscover for "${file.filepath}" at ${Date.now()}`);
-	const runStart = performance.now();
-	let compilation;
-	try {
-		await reportFileQueued(rpc, file, logModule, fileLogLabel);
-		const instrumentationOptions = {
-			projectRoot,
-			relativeExcludedFiles: [
-				toForwardSlash(relative(projectRoot, file.filepath)),
-				...poolOptions._instrumentPoolInternals ? [] : POOL_INTERNAL_PATHS,
-				...relativeUserCoverageExclusions
-			],
-			excludedLibraryFilePrefix: "~lib/",
-			excludedLibraryFileOverridePrefix: poolOptions._instrumentPoolInternals ? INTERNAL_PATH_LIB_PREFIX : void 0,
-			excludedInternalFunctionSubstring: "__vitest_assemblyscript_",
-			coverageMemoryPagesMin: poolOptions.coverageMemoryPagesInitial,
-			coverageMemoryPagesMax: poolOptions.coverageMemoryPagesMax,
-			debug: poolOptions.debugNative
-		};
-		const compilerOptions = {
-			stripInline: poolOptions.stripInline,
-			projectRoot,
-			shouldInstrument: collectCoverage,
-			instrumentationOptions,
-			extraFlags: poolOptions.extraCompilerFlags
-		};
-		const { binary, sourceMap, debugInfo, compileTiming } = await compileAssemblyScript(file.filepath, compilerOptions, logModule, fileLogLabel);
-		file.setupDuration = compileTiming;
-		threadCompilationCount++;
-		debug(`${fileLogPrefix} - TIMING compileAssemblyScript total (thread comp # ${threadCompilationCount}): ${compileTiming.toFixed(2)} ms`);
-		const logMessages = [];
-		const handleLog = (msg, isError = false) => {
-			logMessages.push({
-				msg,
-				time: Date.now(),
-				isError
-			});
-		};
-		const discoverStart = performance.now();
-		await executeWASMDiscovery(binary, sourceMap, base, poolOptions, collectCoverage, handleLog, file, logModule, threadImports, diffOptions);
-		prepareFileTaskForCollection(file, testNamePattern, allowOnly);
-		file.collectDuration = performance.now() - discoverStart;
-		debug(`${fileLogPrefix} - TIMING Discovery Phase: ${file.collectDuration.toFixed(2)} ms`);
-		await Promise.all([reportUserConsoleLogs(rpc, logMessages, logModule, base, file), reportFileCollected(rpc, file, logModule, fileLogLabel)]);
-		debug(() => `${fileLogPrefix} - Collected Test Suite Hierarchy:\n${getFullTaskHierarchy(file)}`);
-		debug(`${fileLogPrefix} - TIMING Compilation and Discovery: ${(performance.now() - runStart).toFixed(2)} ms`);
-		compilation = {
-			filePath: file.filepath,
-			binary,
-			sourceMap,
-			debugInfo
-		};
-	} catch (error) {
-		failFile(file, getTestErrorFromPoolError(createPoolErrorFromAnyError(`${fileLogLabel} - runCompileAndDiscover failure in worker`, POOL_ERROR_NAMES.WASMExecutionHarnessError, error)), runStart);
-		await reportFileQueued(rpc, file, logModule, fileLogLabel);
-		await reportFileError(rpc, file, logModule, fileLogLabel);
-		debug(`${fileLogPrefix} - Reported file error`);
-	} finally {
-		await flushRpcUpdates(rpc);
-		debug(`${fileLogPrefix} - runCompileAndDiscover Completed`);
-	}
-	return compilation;
-}
-
-//#endregion
-export { runCompileAndDiscover };
-//# sourceMappingURL=compile-runner-BNFHRGZO.mjs.map

package/dist/compile-runner-BNFHRGZO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"compile-runner-BNFHRGZO.mjs","names":[],"sources":["../src/pool-thread/runner/compile-runner.ts"],"sourcesContent":["/**\n * Worker thread test runner logic for AssemblyScript Pool\n */\n\nimport { basename, relative } from 'node:path';\nimport type { File } from '@vitest/runner/types';\nimport type { SerializedDiffOptions } from '@vitest/utils/diff';\n\nimport { toForwardSlash } from '../../util/path-utils.js';\n\nimport type {\n  AssemblyScriptCompilerOptions,\n  AssemblyScriptConsoleLog,\n  AssemblyScriptConsoleLogHandler,\n  InstrumentationOptions,\n  ResolvedAssemblyScriptPoolOptions,\n  ThreadImports,\n  WASMCompilation,\n  WorkerRPC,\n} from '../../types/types.js';\nimport {\n  ASSEMBLYSCRIPT_LIB_PREFIX,\n  INTERNAL_FUNCTION_NAME_SUBSTRING,\n  INTERNAL_PATH_LIB_PREFIX,\n  POOL_ERROR_NAMES,\n  POOL_INTERNAL_PATHS,\n} from '../../types/constants.js';\nimport { executeWASMDiscovery } from '../../wasm-executor/index.js';\nimport { debug } from '../../util/debug.js';\nimport {\n  reportFileQueued,\n  reportFileCollected,\n  reportUserConsoleLogs,\n  flushRpcUpdates,\n  reportFileError,\n} from '../rpc-reporter.js';\nimport { createPoolErrorFromAnyError, getTestErrorFromPoolError } from '../../util/pool-errors.js';\nimport { compileAssemblyScript } from '../../compiler/index.js';\nimport {\n  getTaskLogLabel,\n  getTaskLogPrefix,\n} from '../../util/vitest-tasks.js';\nimport {\n  failFile,\n  getFullTaskHierarchy,\n  prepareFileTaskForCollection,\n} from '../../util/vitest-file-tasks.js';\n\nlet threadCompilationCount: number = 0;\n\nexport async function runCompileAndDiscover(\n  file: File,\n  logModule: string,\n  rpc: WorkerRPC,\n  poolOptions: ResolvedAssemblyScriptPoolOptions,\n  projectRoot: string,\n  collectCoverage: boolean,\n  relativeUserCoverageExclusions: string[],\n  threadImports: ThreadImports,\n  diffOptions?: SerializedDiffOptions,\n  testNamePattern?: RegExp,\n  allowOnly?: boolean,\n): Promise<WASMCompilation | undefined> {\n  const base = basename(file.filepath);\n  const fileLogPrefix = getTaskLogPrefix(logModule, base, file);\n  const fileLogLabel = getTaskLogLabel(base, file);\n\n  debug(`${fileLogPrefix} - Beginning runCompileAndDiscover for \"${file.filepath}\" at ${Date.now()}`);\n\n  const runStart = performance.now();\n  let compilation: WASMCompilation | undefined;\n\n  try {\n    await reportFileQueued(rpc, file, logModule, fileLogLabel);\n\n    const relativeTestFilePath = toForwardSlash(relative(projectRoot, file.filepath));\n    const instrumentationOptions: InstrumentationOptions = {\n      projectRoot,\n      relativeExcludedFiles: [\n        relativeTestFilePath,\n        ...(poolOptions._instrumentPoolInternals ? [] : POOL_INTERNAL_PATHS),\n        ...relativeUserCoverageExclusions,\n      ],\n      excludedLibraryFilePrefix: ASSEMBLYSCRIPT_LIB_PREFIX,\n      excludedLibraryFileOverridePrefix: poolOptions._instrumentPoolInternals ? INTERNAL_PATH_LIB_PREFIX : undefined,\n      excludedInternalFunctionSubstring: INTERNAL_FUNCTION_NAME_SUBSTRING,\n      coverageMemoryPagesMin: poolOptions.coverageMemoryPagesInitial,\n      coverageMemoryPagesMax: poolOptions.coverageMemoryPagesMax,\n      debug: poolOptions.debugNative,\n    };\n    const compilerOptions: AssemblyScriptCompilerOptions = {\n      stripInline: poolOptions.stripInline,\n      projectRoot: projectRoot,\n      shouldInstrument: collectCoverage,\n      instrumentationOptions,\n      extraFlags: poolOptions.extraCompilerFlags\n    };\n\n    const { binary, sourceMap, debugInfo, compileTiming } = await compileAssemblyScript(\n      file.filepath,\n      compilerOptions,\n      logModule,\n      fileLogLabel\n    );\n    file.setupDuration = compileTiming;\n    threadCompilationCount++;\n\n    debug(`${fileLogPrefix} - TIMING compileAssemblyScript total `\n      + `(thread comp # ${threadCompilationCount}): ${compileTiming.toFixed(2)} ms`\n    );\n    \n    const logMessages: AssemblyScriptConsoleLog[] = [];\n    const handleLog: AssemblyScriptConsoleLogHandler = (msg: string, isError: boolean = false): void => {\n      logMessages.push({ msg, time: Date.now(), isError });\n    };\n    \n    const discoverStart = performance.now();\n\n    await executeWASMDiscovery(\n      binary,\n      sourceMap,\n      base,\n      poolOptions,\n      collectCoverage,\n      handleLog,\n      file,\n      logModule,\n      threadImports,\n      diffOptions\n    );\n\n    // set skips when using only and/or user test name pattern, skip file task if all tests skipped\n    prepareFileTaskForCollection(file, testNamePattern, allowOnly);\n\n    file.collectDuration = performance.now() - discoverStart;\n    debug(`${fileLogPrefix} - TIMING Discovery Phase: ${file.collectDuration.toFixed(2)} ms`);\n\n    // vitest collect - report discovery results\n    await Promise.all([\n      // Report user console logs\n      reportUserConsoleLogs(rpc, logMessages, logModule, base, file),\n\n      // Report onCollected with collected and filtered tasks\n      reportFileCollected(rpc, file, logModule, fileLogLabel),\n    ]);\n\n    debug(() => `${fileLogPrefix} - Collected Test Suite Hierarchy:\\n${getFullTaskHierarchy(file)}`);\n\n    const totalTime = performance.now() - runStart;\n    debug(`${fileLogPrefix} - TIMING Compilation and Discovery: ${totalTime.toFixed(2)} ms`);\n\n    compilation = {\n      filePath: file.filepath,\n      binary,\n      sourceMap,\n      debugInfo,\n    };\n  } catch (error) {\n    const poolError = createPoolErrorFromAnyError(\n      `${fileLogLabel} - runCompileAndDiscover failure in worker`,\n      POOL_ERROR_NAMES.WASMExecutionHarnessError,\n      error\n    );\n    const testError = getTestErrorFromPoolError(poolError);\n\n    failFile(file, testError, runStart);\n\n    await reportFileQueued(rpc, file, logModule, fileLogLabel);\n    await reportFileError(rpc, file, logModule, fileLogLabel);\n\n    debug(`${fileLogPrefix} - Reported file error`);\n  } finally {\n    await flushRpcUpdates(rpc);\n    debug(`${fileLogPrefix} - runCompileAndDiscover Completed`);\n  }\n\n  return compilation;\n}\n"],"mappings":";;;;;;;;;;;;;AAgDA,IAAI,yBAAiC;AAErC,eAAsB,sBACpB,MACA,WACA,KACA,aACA,aACA,iBACA,gCACA,eACA,aACA,iBACA,WACsC;CACtC,MAAM,OAAO,SAAS,KAAK,SAAS;CACpC,MAAM,gBAAgB,iBAAiB,WAAW,MAAM,KAAK;CAC7D,MAAM,eAAe,gBAAgB,MAAM,KAAK;AAEhD,OAAM,GAAG,cAAc,0CAA0C,KAAK,SAAS,OAAO,KAAK,KAAK,GAAG;CAEnG,MAAM,WAAW,YAAY,KAAK;CAClC,IAAI;AAEJ,KAAI;AACF,QAAM,iBAAiB,KAAK,MAAM,WAAW,aAAa;EAG1D,MAAM,yBAAiD;GACrD;GACA,uBAAuB;IAHI,eAAe,SAAS,aAAa,KAAK,SAAS,CAAC;IAK7E,GAAI,YAAY,2BAA2B,EAAE,GAAG;IAChD,GAAG;IACJ;GACD;GACA,mCAAmC,YAAY,2BAA2B,2BAA2B;GACrG;GACA,wBAAwB,YAAY;GACpC,wBAAwB,YAAY;GACpC,OAAO,YAAY;GACpB;EACD,MAAM,kBAAiD;GACrD,aAAa,YAAY;GACZ;GACb,kBAAkB;GAClB;GACA,YAAY,YAAY;GACzB;EAED,MAAM,EAAE,QAAQ,WAAW,WAAW,kBAAkB,MAAM,sBAC5D,KAAK,UACL,iBACA,WACA,aACD;AACD,OAAK,gBAAgB;AACrB;AAEA,QAAM,GAAG,cAAc,uDACD,uBAAuB,KAAK,cAAc,QAAQ,EAAE,CAAC,KAC1E;EAED,MAAM,cAA0C,EAAE;EAClD,MAAM,aAA8C,KAAa,UAAmB,UAAgB;AAClG,eAAY,KAAK;IAAE;IAAK,MAAM,KAAK,KAAK;IAAE;IAAS,CAAC;;EAGtD,MAAM,gBAAgB,YAAY,KAAK;AAEvC,QAAM,qBACJ,QACA,WACA,MACA,aACA,iBACA,WACA,MACA,WACA,eACA,YACD;AAGD,+BAA6B,MAAM,iBAAiB,UAAU;AAE9D,OAAK,kBAAkB,YAAY,KAAK,GAAG;AAC3C,QAAM,GAAG,cAAc,6BAA6B,KAAK,gBAAgB,QAAQ,EAAE,CAAC,KAAK;AAGzF,QAAM,QAAQ,IAAI,CAEhB,sBAAsB,KAAK,aAAa,WAAW,MAAM,KAAK,EAG9D,oBAAoB,KAAK,MAAM,WAAW,aAAa,CACxD,CAAC;AAEF,cAAY,GAAG,cAAc,sCAAsC,qBAAqB,KAAK,GAAG;AAGhG,QAAM,GAAG,cAAc,wCADL,YAAY,KAAK,GAAG,UACkC,QAAQ,EAAE,CAAC,KAAK;AAExF,gBAAc;GACZ,UAAU,KAAK;GACf;GACA;GACA;GACD;UACM,OAAO;AAQd,WAAS,MAFS,0BALA,4BAChB,GAAG,aAAa,6CAChB,iBAAiB,2BACjB,MACD,CACqD,EAE5B,SAAS;AAEnC,QAAM,iBAAiB,KAAK,MAAM,WAAW,aAAa;AAC1D,QAAM,gBAAgB,KAAK,MAAM,WAAW,aAAa;AAEzD,QAAM,GAAG,cAAc,wBAAwB;WACvC;AACR,QAAM,gBAAgB,IAAI;AAC1B,QAAM,GAAG,cAAc,oCAAoC;;AAG7D,QAAO"}

package/dist/compiler-Dqs-qd3I.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"compiler-Dqs-qd3I.mjs","names":["ascMain"],"sources":["../src/compiler/index.ts"],"sourcesContent":["/**\n * AssemblyScript Compiler\n *\n * Handles compilation of AssemblyScript source code to WASM binaries.\n * Manages compiler options, transforms, and in-memory compilation.\n */\n\nimport { main as ascMain } from 'assemblyscript/asc';\nimport { basename, resolve } from 'node:path';\nimport { access, readFile, writeFile, mkdir } from 'node:fs/promises';\n\nimport type {\n  AssemblyScriptCompilerResult,\n  AssemblyScriptCompilerOptions,\n  NativeAddonInterface\n} from '../types/types.js';\nimport { POOL_ERROR_NAMES } from '../types/constants.js';\nimport { debug } from '../util/debug.js';\nimport { createPoolError, throwPoolErrorIfAborted } from '../util/pool-errors.js';\nimport { clearNativeBuildError, hasNativeBuildError, warnASInstrumentationNotLoaded } from '../util/feature-check.js';\nimport { toForwardSlash } from '../util/path-utils.js';\n\nlet nativeAddon: NativeAddonInterface | undefined;\ntry {\n  nativeAddon = await import('../instrumentation/addon-interface.js');\n  // Addon loaded successfully — clear any stale build error marker (fire and forget)\n  clearNativeBuildError();\n} catch (err: any) {\n  const knownBuildFailure = await hasNativeBuildError();\n  if (knownBuildFailure) {\n    // Marker file exists — coverage provider will warn the user, just debug log here\n    debug(`[Compiler] Native instrumentation addon not loaded (known build failure): ${err?.message ?? String(err)}`);\n  } else {\n    // Unexpected failure — no marker file, warn the user\n    warnASInstrumentationNotLoaded(err?.message ?? String(err));\n  }\n}\n\nconst DEBUG_WRITE_FILES = false;\n\n// Path prefix the AS compiler uses when resolving bare `vitest-pool-assemblyscript/assembly` imports\n// via node_modules. Used to detect self-imports and redirect to local assembly/ dir when running locally in-tree.\nconst POOL_ASSEMBLY_NODE_MODULES_PREFIX = 'node_modules/vitest-pool-assemblyscript/assembly/';\n\n// paths assume that we're running from dist/\nconst STRIP_INLINE_TRANSFORM = resolve(import.meta.dirname, './compiler/transforms/strip-inline.mjs');\nconst DEEP_EQUALS_TRANSFORM = resolve(import.meta.dirname, './compiler/transforms/deep-equals.mjs');\n\nsetImmediate(async () => {\n  try {\n    await access(STRIP_INLINE_TRANSFORM);\n  } catch {\n    throw createPoolError(\n      `AS Compiler strip inline transform file not found at \"${STRIP_INLINE_TRANSFORM}\"`,\n      POOL_ERROR_NAMES.CompilationError\n    );\n  }\n\n  try {\n    await access(DEEP_EQUALS_TRANSFORM);\n  } catch {\n    throw createPoolError(\n      `AS Compiler deep equals transform file not found at \"${DEEP_EQUALS_TRANSFORM}\"`,\n      POOL_ERROR_NAMES.CompilationError\n    );\n  }\n});\n\n/**\n * Compile AssemblyScript source code to WASM binary\n */\nexport async function compileAssemblyScript(\n  filename: string,\n  options: AssemblyScriptCompilerOptions,\n  logModule: string,\n  logLabel: string,\n  signal?: AbortSignal\n): Promise<AssemblyScriptCompilerResult> {\n  throwPoolErrorIfAborted(signal);\n\n  const compileStart = performance.now();\n  const logPrefix = `[${logModule} ASC] ${logLabel}`;\n\n  const { shouldInstrument, instrumentationOptions, extraFlags } = options;\n\n  if (shouldInstrument && !instrumentationOptions) {\n    throw createPoolError(\n      'Instrumentation options are required for coverage instrumentation',\n      POOL_ERROR_NAMES.CompilationError\n    );\n  }\n\n  const stdoutLines: string[] = [];\n  const stderrLines: string[] = [];\n  let binary: Uint8Array | undefined;\n  let sourceMap: string | undefined;\n\n  // Use full path as entry file so AS compiler can resolve relative imports\n  const entryFile = filename;\n  // Use simple output name to avoid AS compiler prepending it to source map paths\n  const outputFile = 'output.wasm';\n\n  debug(`${logPrefix} - Compiling: \"${filename}\"`);\n\n  // Capture stdout/stderr (for potential error reporting)\n  const stdout = {\n    write: (text: string) => {\n      stdoutLines.push(text);\n      return true;\n    }\n  };\n\n  const stderr = {\n    write: (text: string) => {\n      stderrLines.push(text);\n      return true;\n    }\n  };\n\n  // Build compiler flags\n  const compilerFlags = [\n    entryFile,\n\n    // overrideable, though not recommended\n    '--optimizeLevel', '0',           // No optimization for easier debugging\n    '--shrinkLevel', '0',             // No shrink\n    '--runtime', 'stub',              // stub runtime (no GC)\n\n    ...(extraFlags || []),\n\n    // non-overrideable\n    '--outFile', outputFile,\n    '--importMemory',                 // Import memory from JS (enables imports during WASM start)\n    '--debug',                        // Include debug info\n    '--sourceMap',                    // Generate source maps for error reporting\n    '--exportStart', '_start',        // Export start function for explicit initialization control\n    '--exportTable',                  // Export function table for direct test execution\n\n    // Injects deep equality comparison method into user-defined classes for toEqual support\n    '--transform', DEEP_EQUALS_TRANSFORM,\n  ];\n\n  // Add transform to strip @inline decorators if requested\n  // This improves coverage accuracy by preventing functions from being inlined,\n  // and enables correct source-mapped error reporting for errors originating\n  // inside inlined functions.\n  if (options.stripInline === true) {\n    compilerFlags.push(\n      '--transform', STRIP_INLINE_TRANSFORM\n    );\n    debug(`${logPrefix} - Added Transform - Stripping @inline decorators`);\n  }\n\n  // Compile with AssemblyScript compiler\n  const ascStart = performance.now();\n  const result = await ascMain(compilerFlags, {\n    stdout,\n    stderr,\n    // Let AS read from filesystem for import resolution\n    // WASM binary and source map are captured in memory via writeFile callback\n    writeFile: (name: string, contents: string | Uint8Array, _baseDir: string) => {\n      throwPoolErrorIfAborted(signal);\n\n      if (name.endsWith('.wasm') && contents instanceof Uint8Array) {\n        binary = contents;\n        debug(`${logPrefix} - Captured binary in memory: \"${name}\"`);\n      } else if (name.endsWith('.wasm.map') && typeof contents === 'string') {\n        debug(`${logPrefix} - Captured source map in memory: \"${name}\"`);\n        sourceMap = contents;\n      } else {\n        debug(`${logPrefix} - WARNING - Captured Unexpected File: \"${name}\" at baseDir: \"${_baseDir}\"`);\n      }\n    },\n    \n    // Custom readFile enables in-tree resolution of bare pool assembly imports.\n    // When a test file imports 'vitest-pool-assemblyscript/assembly', the AS compiler\n    // resolves it to a node_modules path. This works when the package is installed,\n    // but fails in-tree (the package isn't in its own node_modules). The fallback\n    // redirects these to the local assembly/ directory when the normal path isn't found.\n    readFile: async (filename, baseDir): Promise<string | null> => {\n      const filePath = resolve(baseDir, filename);\n\n      try {\n        return await readFile(filePath, { encoding: 'utf-8' });\n      } catch {\n        // Fallback: when running in-tree, redirect pool assembly imports to local assembly/ dir\n        const normalizedFilename = toForwardSlash(filename);\n        if (normalizedFilename.startsWith(POOL_ASSEMBLY_NODE_MODULES_PREFIX)) {\n          const localSubpath = normalizedFilename.substring(POOL_ASSEMBLY_NODE_MODULES_PREFIX.length);\n          const localPath = resolve(baseDir, 'assembly', localSubpath);\n\n          try {\n            return await readFile(localPath, { encoding: 'utf-8' });\n          } catch {\n            return null;\n          }\n        }\n\n        return null;\n      }\n    },\n  });\n\n  debug(`${logPrefix} - TIMING asc.main: ${(performance.now() - ascStart).toFixed(2)} ms`);\n\n  if (result.error) {\n    const errorMessage = stderrLines.length > 0\n      ? `${result.error.message}\\n\\n${stderrLines.join('')}`\n      : result.error.message;\n\n    throw createPoolError(errorMessage, POOL_ERROR_NAMES.CompilationError, errorMessage);\n  }\n\n  if (!binary) {\n    const errorMessage = stderrLines.length > 0\n      ? `No WASM binary was generated\\n\\nAS Compiler output:\\n${stderrLines.join('')}`\n      : 'No WASM binary was generated';\n\n    throw createPoolError(errorMessage, POOL_ERROR_NAMES.CompilationError);\n  }\n\n  if (!sourceMap) {\n    throw createPoolError('Source map not captured from AssemblyScript Compiler', POOL_ERROR_NAMES.CompilationError);\n  }\n\n  const cleanBinary: Uint8Array = binary;\n  const wasmSourceMap: string = sourceMap;\n\n  debug(`${logPrefix} - Compilation successful, clean binary size: ${cleanBinary.length} bytes`);\n  debug(`${logPrefix} - Source map generated, size: ${wasmSourceMap.length * 2} bytes`);\n  \n  if (DEBUG_WRITE_FILES) {\n    // Write source map for debugging\n    const dir = './debug';\n    // TODO - handle non-.ts extensions\n    const sourceMapFileName = `${basename(filename, '.ts')}.ts.map`;\n    const sourceMapPath = `${dir}/${sourceMapFileName}`;\n\n    // Create directory if it doesn't exist\n    try {\n      await mkdir(dir, { recursive: true });\n    } catch {\n      // Directory already exists or creation failed, continue\n    }\n\n    // Format as well-formed JSON\n    const formattedSourceMap = JSON.stringify(JSON.parse(wasmSourceMap), null, 2);\n\n    writeFile(sourceMapPath, formattedSourceMap, { encoding: 'utf8' });\n    debug(`${logPrefix} - Wrote source map to: \"${sourceMapPath}\"`);\n\n    // Also write WASM binary for inspection\n    const wasmPath = sourceMapPath.replace('.map', '.wasm');\n    writeFile(wasmPath, cleanBinary);\n    debug(`${logPrefix} - Wrote WASM binary to: \"${wasmPath}\"`);\n  }\n\n  // Instrument binary for coverage if requested and available\n  if (options.shouldInstrument && nativeAddon) {\n    throwPoolErrorIfAborted(signal);\n\n    const instrumentStart = performance.now();\n    const wasmBuffer = Buffer.from(cleanBinary);\n    const sourceMapBuffer = Buffer.from(wasmSourceMap);\n\n    const instrumentResult = nativeAddon.instrumentForCoverage(wasmBuffer, sourceMapBuffer, options.instrumentationOptions!, logModule, logLabel);\n    const instCount = instrumentResult.debugInfo.instrumentedFunctionCount;\n\n    const instrumentEnd = performance.now();\n    debug(`${logPrefix} - TIMING Instrumented ${instCount} functions: ${(performance.now() - instrumentStart).toFixed(2)} ms`);\n\n    return {\n      binary: instrumentResult.instrumentedWasm,\n      sourceMap: instrumentResult.sourceMap,\n      debugInfo: instrumentResult.debugInfo,\n      isInstrumented: true,\n      compileTiming: instrumentEnd - compileStart,\n    };\n  }\n\n  // No instrumentation requested\n  return {\n    binary: cleanBinary,\n    sourceMap: wasmSourceMap,\n    isInstrumented: false,\n    compileTiming: performance.now() - compileStart,\n  };\n}\n"],"mappings":"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"}

package/dist/constants-DbxJ3hzg.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants-DbxJ3hzg.mjs","names":[],"sources":["../src/types/constants.ts"],"sourcesContent":["/**\n * Plain Constants\n * \n * Only things that don't require importing ./types to avoid circular dependencies.\n */\n\n\n// ============================================================================\n// General / Shared Constants\n// ============================================================================\n\nexport const ASSEMBLYSCRIPT_POOL_NAME = 'assemblyscript' as const;\n\nexport const AS_POOL_ERROR_TYPE_FLAG = '__as_pool__' as const;\n\nexport const AS_POOL_WORKER_MSG_FLAG = '__as_pool__' as const;\n\nexport const AS_POOL_WASM_IMPORTS_ENV = '__as_pool_env__' as const;\n\nexport const VITEST_WORKER_REQUEST_MSG_FLAG = '__vitest_worker_request__' as const;\n\nexport const VITEST_WORKER_RESPONSE_MSG_FLAG = '__vitest_worker_response__' as const;\n\nexport const COVERAGE_PAYLOAD_FORMATS = {\n  AssemblyScript: 'assemblyscript',\n} as const;\n\n/** Prefix for AssemblyScript compiler strip-inline exclusions and instrumentation exclusions */\nexport const ASSEMBLYSCRIPT_LIB_PREFIX = '~lib/' as const;\n\nexport const INTERNAL_PATH_LIB_PREFIX: string = `${ASSEMBLYSCRIPT_LIB_PREFIX}vitest-pool-assemblyscript/assembly/` as const;\n\nexport const INTERNAL_FUNCTION_NAME_SUBSTRING = '__vitest_assemblyscript_' as const;\n\n/** Paths instrumentation exclusions and assetion error stack frame filtering */\nexport const POOL_INTERNAL_PATHS: string[] = [\n  // AS compiler source maps these as relative paths when running locally\n  'assembly/compare.ts',\n  'assembly/describe.ts',\n  'assembly/expect.ts',\n  'assembly/index.ts',\n  'assembly/options.ts',\n  'assembly/utils.ts',\n  'assembly/test.ts',\n\n  // AS compiler source maps these as library paths when running published version\n  `${INTERNAL_PATH_LIB_PREFIX}compare.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}describe.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}expect.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}index.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}options.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}stringify.ts`,\n  `${INTERNAL_PATH_LIB_PREFIX}test.ts`,\n] as const;\n\n/** Name of the method injected by the deep-equals compiler transform */\nexport const DEEP_EQUALS_INJECTED_METHOD_NAME = '__vitest_assemblyscript_deep_equals' as const;\n\n/**\n * Export alias for pool's equals() function used by injected deep equal method comparison body.\n * Declared with @global in assembly/compare.ts to be available in all source files without import.\n */\nexport const COMPARE_EQUALS_EXPORT_ALIAS = '__vitest_assemblyscript_compare_equals' as const;\n\n/**\n * Name of the @global enum in assembly/compare.ts that represents deep equality comparison results.\n * Used in transform-generated code to reference enum members (e.g. EqualityResult.Equal).\n */\nexport const EQUALITY_RESULT_ENUM_NAME = '__vitest_assemblyscript_EqualityResult' as const;\n\n/**\n * Global alias for the path push function used by injected deep equality method field comparisons.\n * Declared with @global in assembly/compare.ts to be available in all source files without import.\n */\nexport const EQUALS_PATH_PUSH_GLOBAL_ALIAS = '__vitest_assemblyscript_equals_path_push' as const;\n\n/**\n * Global alias for the path pop function used by injected deep equality method field comparisons.\n * Declared with @global in assembly/compare.ts to be available in all source files without import.\n */\nexport const EQUALS_PATH_POP_GLOBAL_ALIAS = '__vitest_assemblyscript_equals_path_pop' as const;\n\n/** Name of the method injected by the compiler transform that returns the runtime class name */\nexport const TYPENAME_INJECTED_METHOD_NAME = '__vitest_assemblyscript_typename' as const;\n\n/** Name of the method injected by the compiler transform that returns stringified field contents */\nexport const STRINGIFY_INJECTED_METHOD_NAME = '__vitest_assemblyscript_stringify' as const;\n\n/**\n * Global alias for the stringifyValue() wrapper used by injected stringify method bodies.\n * Declared with @global in assembly/utils.ts to be available in all source files without import.\n */\nexport const STRINGIFY_VALUE_GLOBAL_ALIAS = '__vitest_assemblyscript_stringify_value' as const;\n\n/** Error names for AssemblyScript test failures reported to vitest */\nexport const TEST_ERROR_NAMES = {\n  /** Assertion evaluated to false within a test function */\n  AssertionError: 'AssertionError',\n  /** WASM runtime called abort after a non-planned user code error */\n  WASMRuntimeError: 'WASMRuntimeError',\n} as const;\n\n/** Error names for internal AssemblyScript pool failures */\nexport const POOL_ERROR_NAMES = {\n  /** AssemblyScript compiler (asc) error */\n  CompilationError: 'CompilationError',\n  /** Native instrumentation and debug info extraction error */\n  WASMInstrumentationError: 'WASMInstrumentationError',\n  /** Unexpected WASM execution error (not a known test error path) */\n  WASMExecutionHarnessError: 'WASMExecutionHarnessError',\n  /** Hybrid coverage provider error */\n  HybridCoverageProviderError: 'HybridCoverageProviderError',\n  /** vitest RPC reporting error */\n  PoolReportingError: 'PoolReportingError',\n  /** User configuration error */\n  PoolConfigError: 'PoolConfigError',\n  /** Generic AssemblyScript pool error */\n  PoolError: 'PoolError',\n  /** User syntax error in test/suite/expect */\n  PoolSyntaxError: 'PoolSyntaxError',\n\n  /** Flow Control: Indicates intentional abort */\n  PoolRunAbortedError: 'PoolRunAbortedError',\n  /**\n   * Flow Control: Indicates WASM execution halt through abort() handler,\n   * and should be handled by reporting an AssemblyScriptTestError to vitest\n   */\n  WASMExecutionAbortError: 'WASMExecutionAbortError',\n  /** Flow Control: Indicates WASM execution halt because test timeout elapsed */\n  WASMExecutionTimeoutError: 'WASMExecutionTimeoutError',\n} as const;\n\n// ============================================================================\n// AssemblyScript Compiler\n// ============================================================================\n\n// Original const enum values defined in assemblyscript.generated.d.ts.\n// These are reexported to avoid access issues with `const enum` exports \n// in assemblyscript, because we're using isolatedModules & isolatedDeclarations\n\nimport * as ascript from 'assemblyscript';\nimport type * as AS from 'assemblyscript';\n\ntype NodeKindMap = Record<keyof typeof AS.NodeKind, number>;\ntype CommonFlagsMap = Record<keyof typeof AS.CommonFlags, number>;\ntype DecoratorKindMap = Record<keyof typeof AS.DecoratorKind, number>;\ntype SourceKindMap = Record<keyof typeof AS.SourceKind, number>;\n\nconst asRuntime = ascript as unknown as {\n  NodeKind: NodeKindMap;\n  CommonFlags: CommonFlagsMap;\n  DecoratorKind: DecoratorKindMap;\n  SourceKind: SourceKindMap;\n};\n\nexport const ASNodeKind: NodeKindMap = asRuntime.NodeKind;\nexport const ASCommonFlags: CommonFlagsMap = asRuntime.CommonFlags;\nexport const ASDecoratorKind: DecoratorKindMap = asRuntime.DecoratorKind;\nexport const ASSourceKind: SourceKindMap = asRuntime.SourceKind;\n"],"mappings":";;;AAuBA,MAAa,2BAA2B,EACtC,gBAAgB,kBACjB;;AAGD,MAAa,4BAA4B;AAEzC,MAAa,2BAAmC,WAA6B;;AAK7E,MAAa,sBAAgC;CAE3C;CACA;CACA;CACA;CACA;CACA;CACA;CAGA,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC5B,GAAG,yBAAyB;CAC7B;;AA0CD,MAAa,mBAAmB;CAE9B,gBAAgB;CAEhB,kBAAkB;CACnB;;AAGD,MAAa,mBAAmB;CAE9B,kBAAkB;CAElB,0BAA0B;CAE1B,2BAA2B;CAE3B,6BAA6B;CAE7B,oBAAoB;CAEpB,iBAAiB;CAEjB,WAAW;CAEX,iBAAiB;CAGjB,qBAAqB;CAKrB,yBAAyB;CAEzB,2BAA2B;CAC5B;AAkBD,MAAM,YAAY;AAOlB,MAAa,aAA0B,UAAU;AACjD,MAAa,gBAAgC,UAAU;AACvD,MAAa,kBAAoC,UAAU;AAC3D,MAAa,eAA8B,UAAU"}