vitest-pool-assemblyscript 0.9.1 → 0.10.1

package/dist/{load-user-imports-Bx5ZlhSm.mjs → load-user-imports-Bcx9NOt9.mjs}

@@ -1,79 +1,11 @@
-import { COVERAGE_PAYLOAD_FORMATS, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS, TEST_ERROR_NAMES } from "./constants-DbxJ3hzg.mjs";
-import { createPoolError, createPoolErrorFromAnyError, debug, debugOverride, getSourceCodeFrameString, toPlaintextStackFrameString, toVitestLikeStackFrameString } from "./debug-DtRAL4rM.mjs";
-import { createAfterSuiteRunMeta, createSuiteTask, createTestTask, createWebAssemblyCallSite, extractCallStack, failTest, getTaskLogLabel, isSuiteOwnFile, parseSourceMap } from "./vitest-tasks-BZ24sghI.mjs";
-import { getShortFunctionName } from "./wasm-names-BFtzQCH4.mjs";
+import { COVERAGE_PAYLOAD_FORMATS, POOL_ERROR_NAMES, TEST_ERROR_NAMES } from "./constants-Bq5KNxXJ.mjs";
+import { createAfterSuiteRunMeta, createSuiteTask, createTestTask, failTestAssertionError, failTestRuntimeError, getTaskLogLabel, isSuiteOwnFile } from "./vitest-file-tasks-vvZzigcF.mjs";
+import { abortWASMExecution, abortWASMExecutionOnSuccess, createPoolError, debug, debugOverride, enhanceTestError, extractCallStack, getExpectedMessageOrAny, wrapPoolError } from "./pool-errors-Bn6YaguR.mjs";
+import { createMemory, decodeAbortInfo, liftString } from "./wasm-memory-C8Nkl2Sz.mjs";
 import { basename, resolve } from "node:path";
-import { createBirpc } from "birpc";
-import { diff } from "@vitest/utils/diff";
-import { SourceMapConsumer } from "source-map";
 import { pathToFileURL } from "node:url";
+import { createBirpc } from "birpc";
 
-//#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
-/**
-* 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
-	};
-}
-
-//#endregion
 //#region src/wasm-executor/wasm-console.ts
 function createWasmConsole(memory, handleLog) {
 	const getMessage = (msgPtr, memory, prefix = "") => {
@@ -165,12 +97,10 @@ function createUserWasmImports(createWasmImports, memory, module, logPrefix) {
 		});
 		debug(`${logPrefix} Created user WASM imports for test execution in ${(performance.now() - start).toFixed(2)} ms`);
 		userEnvImports = userImports?.env;
-		if (userEnvImports) {
-			userCustomEnvImports = { ...userImports };
-			delete userCustomEnvImports.env;
-		}
+		userCustomEnvImports = { ...userImports };
+		if (userEnvImports) delete userCustomEnvImports.env;
 	} catch (error) {
-		throw createPoolErrorFromAnyError(`Error creating user WASM Imports`, POOL_ERROR_NAMES.PoolConfigError, error);
+		throw createPoolError(POOL_ERROR_NAMES.WASMUserImportsError, "Could not create user WasmImportsFactory. Ensure that your module has a default export matching () => WebAssembly.Imports", error, true);
 	}
 	return {
 		userEnvImports,
@@ -190,18 +120,15 @@ function createDiscoveryImports(memory, module, file, handleLog, logPrefix, cove
 			memory,
 			abort(msgPtr, filePtr, line, column) {
 				const { message, location } = decodeAbortInfo(memory, msgPtr, filePtr, line, column);
-				const msgAtLoc = `${message}${location ? ` at ${location}` : ""}`;
-				debug(`${logPrefix} - Unexpected abort during test discovery: ${msgAtLoc}`);
-				const rawCallStack = extractCallStack(/* @__PURE__ */ new Error());
-				const testError = {
+				debug(`${logPrefix} - Unexpected abort during test discovery: ${`${message}${location ? ` at ${location}` : ""}`}`);
+				throw abortWASMExecution({
 					message,
 					name: TEST_ERROR_NAMES.WASMRuntimeError
-				};
-				throw createPoolError(msgAtLoc, POOL_ERROR_NAMES.WASMExecutionAbortError, void 0, testError, rawCallStack);
+				}, /* @__PURE__ */ new Error());
 			}
 		},
 		["__as_pool_env__"]: {
-			...coverageMemory ? { __coverage_memory: coverageMemory } : {},
+			...coverageMemory ? { ["__coverage_memory"]: coverageMemory } : {},
 			__assertion_pass() {},
 			__assertion_fail() {},
 			__expect_throw() {},
@@ -238,6 +165,7 @@ function createDiscoveryImports(memory, module, file, handleLog, logPrefix, cove
 * runtime aborts as expected cases for test execution by capturing the error on the test meta.
 */
 function createTestExecutionImports(memory, module, test, handleLog, logPrefix, coverageMemory, createWasmImports) {
+	let lastFailedAssertion;
 	let isExpectingError = false;
 	let expectedErrorMsgStr;
 	let wasmFunctionTable;
@@ -255,72 +183,72 @@ function createTestExecutionImports(memory, module, test, handleLog, logPrefix,
 					if (isExpectingError) if (!expectedErrorMsgStr || message.includes(expectedErrorMsgStr)) {
 						test.meta.assertionsPassedCount++;
 						debug(`${logPrefix} - Thrown error matches expected - assertion passes`);
-						throw createPoolError(`AssemblyScript abort() import called for expected error throw in test "${test.name}"`, POOL_ERROR_NAMES.WASMExecutionAbortError);
+						throw abortWASMExecutionOnSuccess();
 					} else {
-						failureMessage = `expected function to throw "${expectedErrorMsgStr}" error but received "${message}"`;
-						test.meta.assertionsFailed.push({
+						const expected = getExpectedMessageOrAny(expectedErrorMsgStr);
+						failureMessage = `expected function to throw error ${expected}, but received error "${message}"`;
+						lastFailedAssertion = {
 							message: failureMessage,
-							typeName: "Error",
+							actualTypeName: "string",
+							expectedTypeName: "string",
 							valuesProvided: true,
 							actual: message,
 							expected: expectedErrorMsgStr
-						});
-						debug(`${logPrefix} - Assertion failed: ${`Thrown error does not match expected | Expected: "${expectedErrorMsgStr}" | Actual: "${message}"`}`);
+						};
+						debug(`${logPrefix} - Assertion failed: ${`Thrown error does not match expected | Expected: ${expected} | Actual: "${message}"`}`);
 					}
-					failTest(test, failureMessage, /* @__PURE__ */ new Error(), logPrefix);
-					throw createPoolError(`AssemblyScript abort() import called during test execution for ${test.name}`, POOL_ERROR_NAMES.WASMExecutionAbortError);
+					throw abortWASMExecution(lastFailedAssertion ? failTestAssertionError(test, lastFailedAssertion) : failTestRuntimeError(test, "", failureMessage), /* @__PURE__ */ new Error());
 				}
 			},
 			["__as_pool_env__"]: {
-				...coverageMemory ? { __coverage_memory: coverageMemory } : {},
+				...coverageMemory ? { ["__coverage_memory"]: coverageMemory } : {},
 				__register_test() {},
 				__begin_register_suite() {},
 				__end_register_suite() {},
 				__assertion_pass() {
 					test.meta.assertionsPassedCount++;
 				},
-				__assertion_fail(msgPtr, typeNamePtr, valuesProvided, actualPtr, expectedPtr) {
-					const errorMsg = liftString(memory, msgPtr);
-					const assertionValueType = liftString(memory, typeNamePtr);
-					let actual;
-					let expected;
-					const assertionFailure = {
+				__assertion_fail(msgPtr, actualTypeNamePtr, expectedTypeNamePtr, valuesProvided, actualPtr, expectedPtr) {
+					const errorMsg = liftString(memory, msgPtr) ?? "";
+					const actualTypeName = liftString(memory, actualTypeNamePtr) ?? "";
+					const expectedTypeName = liftString(memory, expectedTypeNamePtr) ?? "";
+					let valuesMsg = " | No Values Provided";
+					lastFailedAssertion = {
+						actualTypeName,
+						expectedTypeName,
 						message: errorMsg,
-						typeName: assertionValueType,
 						valuesProvided: Boolean(valuesProvided)
 					};
+					test.meta.assertionsFailed.push(lastFailedAssertion);
 					if (valuesProvided && actualPtr && expectedPtr) {
-						assertionFailure.actual = liftString(memory, actualPtr);
-						assertionFailure.expected = liftString(memory, expectedPtr);
+						lastFailedAssertion.actual = liftString(memory, actualPtr);
+						lastFailedAssertion.expected = liftString(memory, expectedPtr);
+						valuesMsg = ` | Actual Type: ${actualTypeName} | Expected Type: ${expectedTypeName} | Actual Value: \`${lastFailedAssertion.actual}\` | Expected Value: \`${lastFailedAssertion.expected}\``;
 					}
-					test.meta.assertionsFailed.push(assertionFailure);
-					debug(`${logPrefix} - Assertion failed: ${errorMsg}${valuesProvided ? ` | Value Type: ${assertionValueType} | Expected: \`${expected !== void 0 ? expected : ""}\` | Actual: \`${actual !== void 0 ? actual : ""}\`` : ""}`);
+					debug(`${logPrefix} - Assertion failed: ${errorMsg}${valuesMsg}`);
 				},
 				__expect_throw(fnIndex, expectedErrorMsgPtr) {
 					isExpectingError = true;
 					if (expectedErrorMsgPtr) expectedErrorMsgStr = liftString(memory, expectedErrorMsgPtr);
-					debug(`${logPrefix} - Registered expected error throw: ${expectedErrorMsgStr !== void 0 ? `"${expectedErrorMsgStr}"` : "<any>"}`);
+					debug(`${logPrefix} - Registered expected error throw: ${getExpectedMessageOrAny(expectedErrorMsgStr)}`);
 					if (wasmFunctionTable && typeof wasmFunctionTable.get === "function") {
 						const fn = wasmFunctionTable.get(fnIndex);
-						if (!fn) throw createPoolError(`Could not access function (fnPtr ${fnIndex}) which is expected to throw in test "${test.name}"`, POOL_ERROR_NAMES.WASMExecutionHarnessError);
+						if (!fn) throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, `Could not access function (fnPtr ${fnIndex}) which is expected to throw in test "${test.name}"`);
 						debug(`${logPrefix} - Calling function (idx ${fnIndex})`);
 						fn();
-					} else throw createPoolError(`Could not access WASM function table to call function expected to throw in test "${test.name}"`, POOL_ERROR_NAMES.WASMExecutionHarnessError);
+					} else throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, `Could not access WASM function table to call function expected to throw`);
 				},
 				__end_expect_throw() {
 					if (isExpectingError) {
-						const isAnyErr = !!expectedErrorMsgStr;
-						const failureMessage = `expected function to throw ${isAnyErr ? `"${expectedErrorMsgStr}"` : "any"} error - did not throw`;
-						test.meta.assertionsFailed.push({
-							message: failureMessage,
-							typeName: "Error",
-							valuesProvided: !isAnyErr,
+						debug(`${logPrefix} - Assertion failed: ${`Expected thrown error but got none | Expected: "${expectedErrorMsgStr}"`}`);
+						throw abortWASMExecution(failTestAssertionError(test, {
+							message: `function did not throw, but was expected to throw error: ${getExpectedMessageOrAny(expectedErrorMsgStr)}`,
+							actualTypeName: "undefined",
+							expectedTypeName: "string",
+							valuesProvided: true,
 							actual: void 0,
 							expected: expectedErrorMsgStr
-						});
-						debug(`${logPrefix} - Assertion failed: ${`Expected thrown error but got none | Expected: "${expectedErrorMsgStr}"`}`);
-						failTest(test, failureMessage, /* @__PURE__ */ new Error(), logPrefix);
-						throw createPoolError(`AssemblyScript __end_expect_throw() import called during test execution for ${test.name}`, POOL_ERROR_NAMES.WASMExecutionAbortError);
+						}));
 					}
 				}
 			},
@@ -334,112 +262,58 @@ function createTestExecutionImports(memory, module, test, handleLog, logPrefix,
 }
 
 //#endregion
-//#region src/wasm-executor/wasm-errors.ts
-const POOL_INTERNAL_PATHS_SET = new Set(POOL_INTERNAL_PATHS);
-async function sourceMapRawCallStack(rawCallStack, sourceMap, loggingPrefix) {
-	const mappedStack = [];
-	if (!rawCallStack || rawCallStack.length === 0) return mappedStack;
-	const sourceMapConsumer = await new SourceMapConsumer(sourceMap);
-	rawCallStack.forEach((callSite) => {
-		const mappedCallSite = createWebAssemblyCallSite(callSite, sourceMapConsumer, loggingPrefix);
-		if (mappedCallSite) mappedStack.push(mappedCallSite);
-	});
-	sourceMapConsumer.destroy();
-	return mappedStack;
-}
-function parseMappedStack(mappedStack) {
-	return mappedStack.filter((frame) => !POOL_INTERNAL_PATHS_SET.has(frame.location.filePath)).map((frame) => ({
-		method: getShortFunctionName(frame.functionName),
-		file: frame.location.filePath,
-		line: frame.location.line,
-		column: frame.location.column + 1
-	}));
+//#region src/wasm-executor/index.ts
+const SIG_MISMATCH_ERROR_MSG = "WASM function signature type mismatch during test collection. This is most likely caused by passing a type-inferred, non-void callback to expect(). To fix, either explicitly define the non-void return type on the callback  e.g. `expect((): i32 => failingFunction()).toThrowError()` or use braces to make it void  e.g. `expect(() => { failingFunction(); }).toThrowError()`. Look for the failing expect() within the describe() block indicated in the stack trace.";
+function verifyMemoryRequirements(compilation, poolOptions) {
+	if (poolOptions.testMemoryPagesInitial && poolOptions.testMemoryPagesInitial < compilation.requiredMemory.testMemory.initialPages) throw createPoolError(POOL_ERROR_NAMES.PoolConfigError, `WASM binary requires initial test memory pages (${compilation.requiredMemory.testMemory.initialPages}) exceeding configured "testMemoryPagesInitial" (${poolOptions.testMemoryPagesInitial}). Increase value, or remove for auto sizing.`);
+	if (poolOptions.testMemoryPagesMax && compilation.requiredMemory.testMemory.maximumPages && poolOptions.testMemoryPagesMax < compilation.requiredMemory.testMemory.maximumPages) throw createPoolError(POOL_ERROR_NAMES.PoolConfigError, `WASM binary requires maximum test memory pages (${compilation.requiredMemory.testMemory.maximumPages}) exceeding configured "testMemoryPagesMax" (${poolOptions.testMemoryPagesMax}). Increase value, or remove for auto sizing.`);
+	if (poolOptions.coverageMemoryPagesInitial && poolOptions.coverageMemoryPagesInitial < compilation.requiredMemory.coverageMemory.initialPages) throw createPoolError(POOL_ERROR_NAMES.PoolConfigError, `WASM binary requires initial coverage memory pages (${compilation.requiredMemory.coverageMemory.initialPages}) exceeding configured "coverageMemoryPagesInitial" (${poolOptions.coverageMemoryPagesInitial}). Increase value, or remove for auto sizing.`);
+	if (poolOptions.coverageMemoryPagesMax && compilation.requiredMemory.coverageMemory.maximumPages && poolOptions.coverageMemoryPagesMax < compilation.requiredMemory.coverageMemory.maximumPages) throw createPoolError(POOL_ERROR_NAMES.PoolConfigError, `WASM binary requires maximum coverage memory pages (${compilation.requiredMemory.coverageMemory.maximumPages}) exceeding configured "coverageMemoryPagesMax" (${poolOptions.coverageMemoryPagesMax}). Increase value, or remove for auto sizing.`);
 }
-async function processWASMErrorStack(rawCallStack, sourceMap, loggingPrefix) {
-	const sourceMapObj = parseSourceMap(sourceMap);
-	const sourceMappedStack = await sourceMapRawCallStack(rawCallStack, sourceMapObj, loggingPrefix);
-	debug(`${loggingPrefix} - Mapped ${rawCallStack.length} call sites to ${sourceMappedStack.length} source locations`);
+function createExecutorMemories(compilation, poolOptions, includeCoverageMemory) {
+	verifyMemoryRequirements(compilation, poolOptions);
 	return {
-		parsedStack: parseMappedStack(sourceMappedStack),
-		parsedSourceMap: sourceMapObj
+		testMemory: createMemory(poolOptions.testMemoryPagesInitial ?? compilation.requiredMemory.testMemory.initialPages, poolOptions.testMemoryPagesMax ?? compilation.requiredMemory.testMemory.maximumPages),
+		coverageMemory: includeCoverageMemory ? createMemory(poolOptions.coverageMemoryPagesInitial ?? compilation.requiredMemory.coverageMemory.initialPages, poolOptions.coverageMemoryPagesMax ?? compilation.requiredMemory.coverageMemory.maximumPages) : void 0
 	};
 }
 /**
-* Enhance reportable test error on the provided test result with source mapped stack locations
-* and a formatted diff based on the error type
-*/
-async function enhanceTestError(error, task, sourceMap, valuesProvided, logPrefix, rawCallStack, diffOptions) {
-	const isAssertionFailure = error.name === TEST_ERROR_NAMES.AssertionError;
-	let expectedVsActualDiffString = "";
-	if (isAssertionFailure && valuesProvided) expectedVsActualDiffString = diff(error.expected, error.actual, diffOptions) ?? "";
-	if (!rawCallStack || rawCallStack.length === 0) {
-		error.diff = expectedVsActualDiffString;
-		error.stack = `${task.name} - ${error.message}`;
-		return error;
-	}
-	const { parsedStack, parsedSourceMap } = await processWASMErrorStack(rawCallStack, sourceMap, logPrefix);
-	let primaryStackFrameString;
-	let highlightedSourceCodeFrameString;
-	if (parsedStack.length > 0) {
-		const primaryStackFrame = parsedStack[0];
-		primaryStackFrameString = toVitestLikeStackFrameString(primaryStackFrame);
-		error.stacks = parsedStack.slice(1);
-		highlightedSourceCodeFrameString = getSourceCodeFrameString(parsedSourceMap, primaryStackFrame);
-		debug(`${logPrefix} - Enhanced ${error.name} error with parsed source stack`);
-	}
-	if (isAssertionFailure) error.diff = [
-		`${expectedVsActualDiffString}${expectedVsActualDiffString ? "\n\n" : ""}`,
-		`${primaryStackFrameString}\n`,
-		`${highlightedSourceCodeFrameString}`
-	].join("");
-	else error.diff = [`${primaryStackFrameString}\n`, `${highlightedSourceCodeFrameString}`].join("");
-	error.stack = parsedStack.map(toPlaintextStackFrameString).join("\n");
-	debug(`[${logPrefix} - Enhanced ${error.name} error with diffs`);
-	return error;
-}
-
-//#endregion
-//#region src/wasm-executor/index.ts
-const SIG_MISMATCH_ERROR_MSG = "WASM RuntimeError indicates function signature type mismatch during test suite collection. This is likely caused by passing a non-void callback to expect(). Use braces to ensure it returns void  e.g. `expect(() => { failingFunction(); }).toThrowError()`. Look for the failing expect() within the describe() block indicated in the stack trace.";
-function createExecutorPoolError(testFileBasename, context, reason, cause) {
-	return createPoolError(`${testFileBasename} - ${context} WASM executor: ${reason}`, POOL_ERROR_NAMES.WASMExecutionHarnessError, void 0, cause);
-}
-/**
 * Discover tests via test() and suites via describe() registration calls
 */
-async function executeWASMDiscovery(binary, sourceMap, testFileBasename, poolOptions, isBinaryInstrumented, handleLog, file, moduleLabel, threadImports, diffOptions) {
+async function executeWASMDiscovery(compilation, poolOptions, isBinaryInstrumented, handleLog, file, moduleLabel, threadImports) {
 	const logPrefix = `[${moduleLabel} Exec] ${getTaskLogLabel(basename(file.filepath), file)}`;
-	const wasmModule = await WebAssembly.compile(binary);
-	const importObject = createDiscoveryImports(createMemory(poolOptions.testMemoryPagesInitial, poolOptions.testMemoryPagesMax), wasmModule, file, handleLog, logPrefix, isBinaryInstrumented ? createMemory(poolOptions.coverageMemoryPagesInitial, poolOptions.coverageMemoryPagesMax) : void 0, threadImports.createUserWasmImports);
-	const exports = new WebAssembly.Instance(wasmModule, importObject).exports;
-	if (typeof exports._start === "function") try {
-		exports._start();
+	try {
+		const { testMemory, coverageMemory } = createExecutorMemories(compilation, poolOptions, isBinaryInstrumented);
+		const importObject = createDiscoveryImports(testMemory, compilation.compiledModule, file, handleLog, logPrefix, coverageMemory, threadImports.createUserWasmImports);
+		const exports = new WebAssembly.Instance(compilation.compiledModule, importObject).exports;
+		if (typeof exports._start === "function") exports._start();
+		else throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, "no _start() export found on compiled WASM binary");
 	} catch (error) {
-		const thrownErrAny = error;
-		if (error instanceof WebAssembly.RuntimeError && thrownErrAny?.message.includes("null function or function signature mismatch")) {
-			const runtimeError = error;
-			const stack = extractCallStack(runtimeError);
-			const testError = await enhanceTestError({
-				name: TEST_ERROR_NAMES.WASMRuntimeError,
-				message: runtimeError.message
-			}, file, sourceMap, false, logPrefix, stack, diffOptions);
-			throw createPoolError(`${SIG_MISMATCH_ERROR_MSG}\n Caused by: ${runtimeError.name}: ${runtimeError.message}`, POOL_ERROR_NAMES.PoolSyntaxError, void 0, testError);
+		if (error && error["__as_pool_error__"]) throw error;
+		if (error instanceof WebAssembly.RuntimeError && error.message.includes("null function or function signature mismatch")) throw createPoolError(POOL_ERROR_NAMES.PoolSyntaxError, SIG_MISMATCH_ERROR_MSG, error);
+		if (error instanceof Error) {
+			let match = null;
+			let moduleName;
+			let functionName;
+			let errorMessage;
+			if (match = /"(.+)": module is not an object or function/.exec(error.message)) {
+				moduleName = match[1];
+				errorMessage = `Expected module "${moduleName}" to be defined as an object or function within user WASM imports (returned by WasmImportsFactory).`;
+			} else if (match = /"(.+)" (function=)?"(.+)": function import requires a callable/.exec(error.message)) {
+				moduleName = match[1];
+				functionName = match[3];
+				errorMessage = `Expected function "${functionName}" to be defined in module "${moduleName}" within user WASM imports (returned by WasmImportsFactory).`;
+			}
+			if (errorMessage) throw createPoolError(POOL_ERROR_NAMES.WASMUserImportsError, errorMessage, error);
 		}
-		if (thrownErrAny?.name === POOL_ERROR_NAMES.WASMExecutionAbortError && thrownErrAny?.cause?.name === TEST_ERROR_NAMES.WASMRuntimeError && error.rawCallStack) {
-			const thrownPoolErr = thrownErrAny;
-			thrownPoolErr.cause = await enhanceTestError(thrownPoolErr.cause, file, sourceMap, false, logPrefix, thrownPoolErr.rawCallStack, diffOptions);
-			thrownPoolErr.causeIsEnhancedError = true;
-			delete thrownPoolErr.rawCallStack;
-			throw thrownPoolErr;
-		} else throw createPoolErrorFromAnyError(`${testFileBasename} - Unexpected discovery error`, POOL_ERROR_NAMES.WASMExecutionHarnessError, error);
+		throw wrapPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, error, true);
 	}
-	else throw createExecutorPoolError(testFileBasename, "discoverTests", "no _start() export");
 	debug(`${logPrefix} - Discovered ${file.tasks.length} top-level tasks`);
 }
 /**
 * Execute a single test with crash isolation
 */
-async function executeWASMTest(test, compilation, testFileBasename, poolOptions, collectCoverage, handleLog, moduleLabel, threadImports, diffOptions) {
+async function executeWASMTest(test, compilation, poolOptions, collectCoverage, handleLog, moduleLabel, threadImports, projectRoot, diffOptions) {
 	const testTimings = {
 		fnInit: performance.now(),
 		execStart: 0,
@@ -451,40 +325,51 @@ async function executeWASMTest(test, compilation, testFileBasename, poolOptions,
 	function covDebug(...args) {
 		if (poolOptions.debugCoverageExtract) debugOverride(...args);
 	}
-	const wasmModule = await WebAssembly.compile(compilation.binary);
-	const memory = createMemory(poolOptions.testMemoryPagesInitial, poolOptions.testMemoryPagesMax);
-	const coverageMemory = collectCoverage ? createMemory(poolOptions.coverageMemoryPagesInitial, poolOptions.coverageMemoryPagesMax) : void 0;
-	const { imports, provideFunctionTable } = createTestExecutionImports(memory, wasmModule, test, handleLog, logPrefix, coverageMemory, threadImports.createUserWasmImports);
-	const exports = new WebAssembly.Instance(wasmModule, imports).exports;
+	const { testMemory, coverageMemory } = createExecutorMemories(compilation, poolOptions, collectCoverage);
+	const { imports, provideFunctionTable } = createTestExecutionImports(testMemory, compilation.compiledModule, test, handleLog, logPrefix, coverageMemory, threadImports.createUserWasmImports);
+	const exports = new WebAssembly.Instance(compilation.compiledModule, imports).exports;
 	const table = exports.table;
 	if (table && typeof table.get === "function") provideFunctionTable(table);
 	if (typeof exports._start === "function") exports._start();
-	else throw createExecutorPoolError(testFileBasename, "executeWASMTest", "no _start() export");
+	else throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, "no _start() export found on compiled WASM binary");
 	let testFn;
 	if (table && typeof table.get === "function") {
 		const idx = test.meta.fnIndex;
 		testFn = table.get(idx);
-		if (!testFn) throw createExecutorPoolError(testFileBasename, "executeWASMTest", `Test function at index ${idx} not found in function table`);
-	} else throw createExecutorPoolError(testFileBasename, "executeWASMTest", "Function table not found in WASM exports (missing --exportTable flag?)");
+		if (!testFn) throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, `Test function at index ${idx} not found in function table`);
+	} else throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, "Function table not found in WASM exports (missing --exportTable flag?)");
 	try {
 		testTimings.execStart = performance.now();
 		testFn();
 		testTimings.execEnd = performance.now();
 	} catch (error) {
 		testTimings.execEnd = performance.now();
-		if (error?.name !== POOL_ERROR_NAMES.WASMExecutionAbortError) throw createExecutorPoolError(testFileBasename, "executeWASMTest", `Unexpected execution error: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`, error?.cause);
+		let testError;
+		let stack;
+		let allowStackJS;
+		let applyStackToTestErrorCause;
+		if (error && error["__as_pool_error__"]) {
+			const wrapper = error;
+			testError = wrapper.testError;
+			stack = wrapper.originalErrorRawStack;
+			allowStackJS = wrapper.originalErrorMayContainJS;
+			applyStackToTestErrorCause = wrapper.applyStackToTestErrorCause;
+		} else if (error instanceof Error) {
+			testError = failTestRuntimeError(test, error.name, error.message);
+			stack = extractCallStack(error);
+			allowStackJS = true;
+			applyStackToTestErrorCause = false;
+		} else {
+			testError = failTestRuntimeError(test, "", `Unexpected WASM test execution error: ${String(error)}`);
+			stack = extractCallStack(/* @__PURE__ */ new Error());
+			allowStackJS = true;
+			applyStackToTestErrorCause = false;
+		}
+		await enhanceTestError(testError, test, compilation.sourceMap, logPrefix, allowStackJS, projectRoot, applyStackToTestErrorCause, stack, diffOptions);
 	}
 	const meta = test.meta;
-	if (meta.lastError) {
-		const enhancedError = await enhanceTestError(meta.lastError, test, compilation.sourceMap, meta.lastErrorValuesProvided ?? false, logPrefix, meta.lastErrorRawCallStack, diffOptions);
-		if (test.result) if (test.result.errors) test.result.errors.push(enhancedError);
-		else test.result.errors = [enhancedError];
-		delete meta.lastError;
-		delete meta.lastErrorValuesProvided;
-		delete meta.lastErrorRawCallStack;
-	}
 	if (collectCoverage && compilation.debugInfo) {
-		if (!coverageMemory) throw createExecutorPoolError(testFileBasename, "executeWASMTest", "Coverage memory not created despite collectCoverage=true");
+		if (!coverageMemory) throw createPoolError(POOL_ERROR_NAMES.WASMExecutionHarnessError, "Coverage memory not created despite collectCoverage=true");
 		const coverage = { hitCountsByFileAndPosition: {} };
 		const extractedHitCounters = new Uint32Array(coverageMemory.buffer, 0, compilation.debugInfo.instrumentedFunctionCount);
 		covDebug(`${logPrefix} - Read coverage memory for ${compilation.debugInfo.instrumentedFunctionCount} instrumented functions`);
@@ -668,15 +553,17 @@ async function loadUserWasmImportsFactory(relativePath, projectRoot, logModule)
 	try {
 		const start = performance.now();
 		const createWasmImports = (await import(safeUrl)).default;
-		debug(`[${logModule}] TIMING Imported user WasmImportsFactory in ${(performance.now() - start).toFixed(2)} ms`);
-		if (typeof createWasmImports !== "function") throw new Error(`User config for \`wasmImportsFactor\` must be the path to a module with a default export matching () => WebAssembly.Imports - Imported: "${typeof createWasmImports}": ${String(createWasmImports)}`);
-		else return createWasmImports;
+		debug(`[${logModule}] Imported user WasmImportsFactory "${safeUrl}" | TIMING ${(performance.now() - start).toFixed(2)} ms`);
+		if (typeof createWasmImports !== "function") {
+			const msg = `Could not load user WasmImportsFactory from "${safeUrl}". Ensure that your module has a default export matching () => WebAssembly.Imports \nDefault export type is currently "${typeof createWasmImports}"`;
+			throw createPoolError(POOL_ERROR_NAMES.WASMUserImportsError, msg);
+		} else return createWasmImports;
 	} catch (error) {
-		if (error["__as_pool__"]) throw error;
-		throw new Error(`Could not load user WasmImportsFactory from "${safeUrl}". Ensure that your module path is relative to the project root (location of shallowest vitest config), and that it has a default export matching () => WebAssembly.Imports`, { cause: error });
+		const msg = `Could not load user WasmImportsFactory from "${safeUrl}". Ensure that your module path is relative to the project root (location of shallowest vitest config), and that it has a default export matching () => WebAssembly.Imports`;
+		throw createPoolError(POOL_ERROR_NAMES.WASMUserImportsError, msg, error, true);
 	}
 }
 
 //#endregion
 export { createRpcClient, executeWASMDiscovery, executeWASMTest, flushRpcUpdates, loadUserWasmImportsFactory, reportFileCollected, reportFileError, reportFileQueued, reportSuiteFinished, reportSuitePrepare, reportTestFinished, reportTestPrepare, reportTestRetried, reportUserConsoleLogs };
-//# sourceMappingURL=load-user-imports-Bx5ZlhSm.mjs.map
+//# sourceMappingURL=load-user-imports-Bcx9NOt9.mjs.map