vitest-pool-assemblyscript 0.2.0

package/dist/load-user-imports-J9eaAW0_.mjs

@@ -0,0 +1,801 @@
+import { COVERAGE_PAYLOAD_FORMATS, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS, TEST_ERROR_NAMES } from "./constants-CA50WBdr.mjs";
+import { createPoolError, createPoolErrorFromAnyError, debug, getSourceCodeFrameString, isDebugModeEnabled, toPlaintextStackFrameString, toVitestLikeStackFrameString } from "./debug-IeEHsxy0.mjs";
+import { createAfterSuiteRunMeta, createSuiteTask, createTestTask, createWebAssemblyCallSite, extractCallStack, failTest, getTaskLogLabel, isSuiteOwnFile, parseSourceMap } from "./vitest-tasks-BKS7689f.mjs";
+import { basename, resolve } from "node:path";
+import { createBirpc } from "birpc";
+import { diff } from "@vitest/utils/diff";
+import { SourceMapConsumer } from "source-map";
+
+//#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 = "") => {
+		return `${prefix}${msgPtr ? liftString(memory, msgPtr) : "<no message>"}`;
+	};
+	const timersByLabel = {};
+	return {
+		"console.assert": (assertion, msgPtr) => {
+			if (!assertion) {
+				const msg = getMessage(msgPtr, memory);
+				handleLog(`Assertion failed${msg ? `: ${msg}` : ""}`);
+			}
+		},
+		"console.log": (msgPtr) => {
+			handleLog(getMessage(msgPtr, memory));
+		},
+		"console.debug": (msgPtr) => {
+			handleLog(getMessage(msgPtr, memory, "Debug: "));
+		},
+		"console.info": (msgPtr) => {
+			handleLog(getMessage(msgPtr, memory, "Info: "));
+		},
+		"console.warn": (msgPtr) => {
+			handleLog(getMessage(msgPtr, memory, "Warning: "), true);
+		},
+		"console.error": (msgPtr) => {
+			handleLog(getMessage(msgPtr, memory, "Error: "), true);
+		},
+		"console.time": (labelPtr) => {
+			const label = labelPtr ? liftString(memory, labelPtr) ?? "default" : "default";
+			timersByLabel[label] = performance.now();
+		},
+		"console.timeLog": (labelPtr) => {
+			const label = labelPtr ? liftString(memory, labelPtr) ?? "default" : "default";
+			const start = timersByLabel[label];
+			let msg = "";
+			if (start === void 0) msg = `Warning: No such label '${label}' for console.timeLog()`;
+			else msg = `${label}: ${(performance.now() - start).toFixed(3)}ms`;
+			handleLog(msg);
+		},
+		"console.timeEnd": (labelPtr) => {
+			const label = labelPtr ? liftString(memory, labelPtr) ?? "default" : "default";
+			const start = timersByLabel[label];
+			let msg = "";
+			if (start === void 0) msg = `Warning: No such label '${label}' for console.timeLog()`;
+			else msg = `${label}: ${(performance.now() - start).toFixed(3)}ms`;
+			handleLog(msg);
+			delete timersByLabel[label];
+		},
+		trace(msgPtr, n, a0, a1, a2, a3) {
+			const msg = liftString(memory, msgPtr);
+			const args = [
+				a0,
+				a1,
+				a2,
+				a3
+			];
+			const nArgs = n && n > 0 ? args.slice(0, n) : args;
+			console.trace(`WASM Trace:${msg ? ` ${msg}` : ""}`, ...nArgs);
+		}
+	};
+}
+
+//#endregion
+//#region src/wasm-executor/collect-options.ts
+const TEST_OPTION_UNDEFINED = -1;
+const TEST_OPTION_TRUE = 1;
+function mergeAssemblyScriptTestOptions(baseOptions, timeout, retry, skip, only, fails) {
+	const options = { ...baseOptions };
+	if (timeout > TEST_OPTION_UNDEFINED) options.timeout = timeout;
+	if (retry > TEST_OPTION_UNDEFINED) options.retry = retry;
+	if (skip > TEST_OPTION_UNDEFINED) options.skip = skip === TEST_OPTION_TRUE ? true : false;
+	if (only > TEST_OPTION_UNDEFINED) options.only = only === TEST_OPTION_TRUE ? true : false;
+	if (fails > TEST_OPTION_UNDEFINED) options.fails = fails === TEST_OPTION_TRUE ? true : false;
+	return options;
+}
+
+//#endregion
+//#region src/wasm-executor/wasm-imports.ts
+function createUserWasmImports(createWasmImports, memory, module, logPrefix) {
+	let userEnvImports;
+	let userCustomEnvImports;
+	if (createWasmImports) try {
+		const start = performance.now();
+		const userImports = createWasmImports({
+			memory,
+			module,
+			utils: { liftString: (stringPtr) => liftString(memory, stringPtr) }
+		});
+		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;
+		}
+	} catch (error) {
+		throw createPoolErrorFromAnyError(`Error creating user WASM Imports`, POOL_ERROR_NAMES.PoolConfigError, error);
+	}
+	return {
+		userEnvImports,
+		userCustomEnvImports
+	};
+}
+/**
+* Create import object for test discovery
+*/
+function createDiscoveryImports(memory, module, file, handleLog, logPrefix, coverageMemory, createWasmImports) {
+	const suiteStack = [file];
+	const { userEnvImports, userCustomEnvImports } = createUserWasmImports(createWasmImports, memory, module, logPrefix);
+	return {
+		env: {
+			...createWasmConsole(memory, handleLog),
+			...userEnvImports ?? {},
+			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 = {
+					message,
+					name: TEST_ERROR_NAMES.WASMRuntimeError
+				};
+				throw createPoolError(msgAtLoc, POOL_ERROR_NAMES.WASMExecutionAbortError, void 0, testError, rawCallStack);
+			}
+		},
+		["__as_pool_env__"]: {
+			...coverageMemory ? { __coverage_memory: coverageMemory } : {},
+			__assertion_pass() {},
+			__assertion_fail() {},
+			__expect_throw() {},
+			__end_expect_throw() {},
+			__begin_register_suite(namePtr, timeout, retry, skip, only, fails) {
+				const parentSuite = suiteStack[suiteStack.length - 1];
+				const defaultTestOptions = parentSuite.meta.defaultTestOptions;
+				const suiteName = liftString(memory, namePtr) ?? "unknown suite";
+				const options = mergeAssemblyScriptTestOptions(defaultTestOptions, timeout, retry, skip, only, fails);
+				const suite = createSuiteTask(suiteName, file, parentSuite, options);
+				suiteStack.push(suite);
+				debug(`${logPrefix} - Registering Suite "${suite.name}" | timeout: ${options.timeout} ms | retry: ${options.retry} | skip: ${options.skip} | only: ${options.only} | fails: ${options.fails}  | parent: "${suite.suite?.name}" (parent idx: ${suite.meta.idxInParentTasks})`);
+			},
+			__end_register_suite(_namePtr) {
+				const suite = suiteStack.pop();
+				debug(`${logPrefix} - Registered Suite "${suite?.name}" | ${suite?.tasks.length} top-level tasks | mode: "${suite?.mode}" | parent: "${suite?.suite?.name}" (parent idx: ${(suite?.meta)?.idxInParentTasks})`);
+			},
+			__register_test(namePtr, fnIndex, timeout, retry, skip, only, fails) {
+				const parentSuite = suiteStack[suiteStack.length - 1];
+				const defaultTestOptions = parentSuite.meta.defaultTestOptions;
+				const testName = liftString(memory, namePtr) ?? "unknown test";
+				const options = mergeAssemblyScriptTestOptions(defaultTestOptions, timeout, retry, skip, only, fails);
+				const test = createTestTask(testName, fnIndex, file, parentSuite, options);
+				debug(`${logPrefix} - Registered test "${test.name}" | mode (pre-interp): "${test.mode}" | fnIndex ${fnIndex} | timeout: ${options.timeout} ms | retry: ${options.retry} | skip: ${options.skip} | only: ${options.only} | fails: ${options.fails} | suite: "${test.suite?.name}" (parent idx: ${test.meta.idxInParentTasks})`);
+			}
+		},
+		...userCustomEnvImports ?? {}
+	};
+}
+/**
+* Create import object for test execution
+*
+* Used during test execution to capture test results / assertions, and to handle
+* 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 isExpectingError = false;
+	let expectedErrorMsgStr;
+	let wasmFunctionTable;
+	const { userEnvImports, userCustomEnvImports } = createUserWasmImports(createWasmImports, memory, module, logPrefix);
+	return {
+		imports: {
+			env: {
+				...createWasmConsole(memory, handleLog),
+				...userEnvImports ?? {},
+				memory,
+				abort(msgPtr, filePtr, line, column) {
+					const { message, location } = decodeAbortInfo(memory, msgPtr, filePtr, line, column);
+					debug(`${logPrefix} - Handling test execution abort: ${`${message}${location ? ` at ${location}` : ""}`}`);
+					let failureMessage = message;
+					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);
+					} else {
+						failureMessage = `expected function to throw "${expectedErrorMsgStr}" error but received "${message}"`;
+						test.meta.assertionsFailed.push({
+							message: failureMessage,
+							typeName: "Error",
+							valuesProvided: true,
+							actual: message,
+							expected: expectedErrorMsgStr
+						});
+						debug(`${logPrefix} - Assertion failed: ${`Thrown error does not match expected | Expected: "${expectedErrorMsgStr}" | 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);
+				}
+			},
+			["__as_pool_env__"]: {
+				...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 = {
+						message: errorMsg,
+						typeName: assertionValueType,
+						valuesProvided: Boolean(valuesProvided)
+					};
+					if (valuesProvided && actualPtr && expectedPtr) {
+						assertionFailure.actual = liftString(memory, actualPtr);
+						assertionFailure.expected = liftString(memory, expectedPtr);
+					}
+					test.meta.assertionsFailed.push(assertionFailure);
+					debug(`${logPrefix} - Assertion failed: ${errorMsg}${valuesProvided ? ` | Value Type: ${assertionValueType} | Expected: \`${expected !== void 0 ? expected : ""}\` | Actual: \`${actual !== void 0 ? actual : ""}\`` : ""}`);
+				},
+				__expect_throw(fnIndex, expectedErrorMsgPtr) {
+					isExpectingError = true;
+					if (expectedErrorMsgPtr) expectedErrorMsgStr = liftString(memory, expectedErrorMsgPtr);
+					debug(`${logPrefix} - Registered expected error throw: ${expectedErrorMsgStr !== void 0 ? `"${expectedErrorMsgStr}"` : "<any>"}`);
+					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);
+						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);
+				},
+				__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,
+							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);
+					}
+				}
+			},
+			...userCustomEnvImports ?? {}
+		},
+		provideFunctionTable: (table) => {
+			debug(`${logPrefix} - Got WASM function table | length: ${table.length}`);
+			wasmFunctionTable = table;
+		}
+	};
+}
+
+//#endregion
+//#region src/wasm-executor/wasm-names.ts
+/**
+* Extracts the short name from a WASM function table name identifier.
+*/
+function getShortFunctionName(fullName) {
+	if (!fullName) return "";
+	let decoded;
+	try {
+		decoded = decodeURIComponent(fullName);
+	} catch {
+		decoded = fullName;
+	}
+	let angleBracketDepth = 0;
+	let parenDepth = 0;
+	let lastSlashOutsideBrackets = -1;
+	for (let i = 0; i < decoded.length; i++) {
+		const char = decoded[i];
+		if (char === "<") angleBracketDepth++;
+		else if (char === ">" && decoded[i - 1] !== "=") angleBracketDepth--;
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth--;
+		else if (char === "/" && angleBracketDepth === 0 && parenDepth === 0) lastSlashOutsideBrackets = i;
+	}
+	const functionPart = lastSlashOutsideBrackets >= 0 ? decoded.substring(lastSlashOutsideBrackets + 1) : decoded;
+	const anonymousMatch = functionPart.match(/^.+~(anonymous\|\d+)$/);
+	if (anonymousMatch) return anonymousMatch[1];
+	return shortenTypePart(functionPart);
+}
+/**
+* Finds the index of the closing '>' that matches the opening '<' at openIndex.
+*/
+function findMatchingCloseBracket(str, openIndex) {
+	let angleBracketDepth = 1;
+	for (let i = openIndex + 1; i < str.length; i++) {
+		const char = str[i];
+		if (char === "<") angleBracketDepth++;
+		else if (char === ">" && str[i - 1] !== "=") {
+			angleBracketDepth--;
+			if (angleBracketDepth === 0) return i;
+		}
+	}
+	return str.length - 1;
+}
+/**
+* Finds the index of the closing ')' that matches the opening '(' at openIndex.
+*/
+function findMatchingCloseParen(str, openIndex) {
+	let parenDepth = 1;
+	let angleBracketDepth = 0;
+	for (let i = openIndex + 1; i < str.length; i++) {
+		const char = str[i];
+		if (char === "(") parenDepth++;
+		else if (char === ")") {
+			parenDepth--;
+			if (parenDepth === 0) return i;
+		} else if (char === "<") angleBracketDepth++;
+		else if (char === ">" && str[i - 1] !== "=") angleBracketDepth--;
+	}
+	return str.length - 1;
+}
+/**
+* Splits a string by commas at the top level (not inside <> or ()).
+*/
+function splitByTopLevelComma(str) {
+	const parts = [];
+	let current = "";
+	let angleBracketDepth = 0;
+	let parenDepth = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str[i];
+		if (char === "<") angleBracketDepth++;
+		else if (char === ">" && str[i - 1] !== "=") angleBracketDepth--;
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth--;
+		else if (char === "," && angleBracketDepth === 0 && parenDepth === 0) {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	parts.push(current);
+	return parts;
+}
+/**
+* Processes the content inside generic brackets or function args.
+*/
+function shortenGenericContent(content) {
+	return splitByTopLevelComma(content).map((part) => shortenTypePart(part.trim())).join(",");
+}
+/**
+* Shortens a function type like (args)=>returnType.
+*/
+function shortenFunctionType(part) {
+	const closeParenIndex = findMatchingCloseParen(part, 0);
+	const argsContent = part.substring(1, closeParenIndex);
+	const afterParen = part.substring(closeParenIndex + 1);
+	const shortenedArgs = argsContent ? shortenGenericContent(argsContent) : "";
+	let returnPart = afterParen;
+	if (afterParen.startsWith("=>") && afterParen.length > 2) returnPart = "=>" + shortenTypePart(afterParen.substring(2));
+	return "(" + shortenedArgs + ")" + returnPart;
+}
+/**
+* Shortens a type/function part, processing paths and generics recursively.
+*/
+function shortenTypePart(part) {
+	if (part.startsWith("(")) return shortenFunctionType(part);
+	const openBracket = part.indexOf("<");
+	if (openBracket === -1) {
+		if (!part.includes("/")) return part;
+		return part.substring(part.lastIndexOf("/") + 1);
+	}
+	const namePart = part.substring(0, openBracket);
+	const closeBracket = findMatchingCloseBracket(part, openBracket);
+	const genericContent = part.substring(openBracket + 1, closeBracket);
+	const name = namePart.includes("/") ? namePart.substring(namePart.lastIndexOf("/") + 1) : namePart;
+	const shortenedContent = shortenGenericContent(genericContent);
+	return name + "<" + shortenedContent + ">";
+}
+
+//#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, isAssertionFailure) {
+	return mappedStack.filter((frame) => !(isAssertionFailure && 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
+	}));
+}
+async function processWASMErrorStack(rawCallStack, sourceMap, isAssertionFailure, loggingPrefix) {
+	const sourceMapObj = parseSourceMap(sourceMap);
+	const sourceMappedStack = await sourceMapRawCallStack(rawCallStack, sourceMapObj, loggingPrefix);
+	debug(`${loggingPrefix} - Mapped ${rawCallStack.length} call sites to ${sourceMappedStack.length} source locations`);
+	return {
+		parsedStack: parseMappedStack(sourceMappedStack, isAssertionFailure),
+		parsedSourceMap: sourceMapObj
+	};
+}
+/**
+* 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, highlight, 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, isAssertionFailure, 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, highlight);
+		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 covDebug(...args) {}
+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) {
+	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.createWasmImports);
+	const exports = new WebAssembly.Instance(wasmModule, importObject).exports;
+	if (typeof exports._start === "function") try {
+		exports._start();
+	} 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, threadImports.highlight, stack, diffOptions);
+			throw createPoolError(`${SIG_MISMATCH_ERROR_MSG}\n Caused by: ${runtimeError.name}: ${runtimeError.message}`, POOL_ERROR_NAMES.PoolSyntaxError, void 0, testError);
+		}
+		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, threadImports.highlight, thrownPoolErr.rawCallStack, diffOptions);
+			thrownPoolErr.causeIsEnhancedError = true;
+			delete thrownPoolErr.rawCallStack;
+			throw thrownPoolErr;
+		} else throw createPoolErrorFromAnyError(`${testFileBasename} - Unexpected discovery error`, POOL_ERROR_NAMES.WASMExecutionHarnessError, error);
+	}
+	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) {
+	const testTimings = {
+		fnInit: performance.now(),
+		execStart: 0,
+		execEnd: 0,
+		fnfinal: 0
+	};
+	const base = basename(test.file.filepath);
+	const logPrefix = `[${`${moduleLabel} Exec`}] ${getTaskLogLabel(base, test)}`;
+	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.createWasmImports);
+	const exports = new WebAssembly.Instance(wasmModule, 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");
+	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?)");
+	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);
+	}
+	const meta = test.meta;
+	if (meta.lastError) {
+		const enhancedError = await enhanceTestError(meta.lastError, test, compilation.sourceMap, meta.lastErrorValuesProvided ?? false, logPrefix, threadImports.highlight, 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) {
+		if (!coverageMemory) throw createExecutorPoolError(testFileBasename, "executeWASMTest", "Coverage memory not created despite collectCoverage=true");
+		if (!compilation.debugInfo) throw createExecutorPoolError(testFileBasename, "executeWASMTest", "debugInfo is required when 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`);
+		let functionsHit = 0;
+		for (const [filePath, debugFunctions] of Object.entries(compilation.debugInfo.functionsByFileAndPosition)) {
+			if (!coverage.hitCountsByFileAndPosition[filePath]) {
+				coverage.hitCountsByFileAndPosition[filePath] = {};
+				covDebug(`${logPrefix} - Extracting hits for source file "${filePath}"`);
+			}
+			for (const [positionKey, funcInfo] of Object.entries(debugFunctions)) {
+				if (funcInfo.coverageMemoryIndex === void 0) {
+					debug(`${logPrefix} - WARNING: NO COVERAGE MEMORY INDEX - func "${funcInfo.name}" (${positionKey}) Skipping hit extraction`);
+					continue;
+				}
+				const hitCount = extractedHitCounters[funcInfo.coverageMemoryIndex] ?? 0;
+				covDebug(`${logPrefix} - func "${funcInfo.name}" (${positionKey}) [idx: ${funcInfo.coverageMemoryIndex}]: ${hitCount} hits`);
+				if (coverage.hitCountsByFileAndPosition[filePath][positionKey] !== void 0) debug(`${logPrefix} - WARNING: DUPLICATE POSITION - func "${funcInfo.name}" (${positionKey}) already extracted to coverage for ${filePath}`);
+				coverage.hitCountsByFileAndPosition[filePath][positionKey] = hitCount;
+				if (hitCount > 0) functionsHit++;
+			}
+		}
+		meta.coverageData = coverage;
+		debug(`${logPrefix} - Extracted coverage data | ${functionsHit} functions hit`);
+	}
+	testTimings.fnfinal = performance.now();
+	return {
+		test,
+		testTimings
+	};
+}
+
+//#endregion
+//#region src/pool-thread/rpc-reporter.ts
+const DEBUG_RPC = isDebugModeEnabled();
+function rpcDebug(...args) {
+	if (DEBUG_RPC) debug(...args);
+}
+/** Create RPC client from MessagePort */
+function createRpcClient(port) {
+	return createBirpc({ onCancel: (_reason) => void 0 }, {
+		post: (v) => port.postMessage(v),
+		on: (fn) => port.on("message", fn)
+	});
+}
+/** Report file as queued (before compilation & discovery starts) */
+async function reportFileQueued(rpc, fileTask, logModule, logLabel) {
+	await rpc.onQueued(fileTask);
+	rpcDebug(`[${logModule} RPC] ${logLabel} - Reported onQueued for file "${fileTask.filepath}" | mode: "${fileTask.mode}" | state: "${fileTask.result ? fileTask.result.state : "--"}"`);
+}
+/** Report file collection complete with full task tree */
+async function reportFileCollected(rpc, fileTask, logModule, logLabel) {
+	await rpc.onCollected([fileTask]);
+	rpcDebug(`[${logModule} RPC] ${logLabel} - Reported onCollected for file "${fileTask.filepath}" | ${fileTask.tasks.length} tasks | mode: "${fileTask.mode}" | state: "${fileTask.result?.state}"`);
+}
+/** Report file-level error (compilation/discovery failure) as "suite-failed-early" */
+async function reportFileError(rpc, fileTask, logModule, logLabel) {
+	const taskPack = [
+		fileTask.id,
+		fileTask.result,
+		{}
+	];
+	const eventPack = [
+		fileTask.id,
+		"suite-failed-early",
+		void 0
+	];
+	await rpc.onTaskUpdate([taskPack], [eventPack]);
+	rpcDebug(`[${logModule} RPC] ${logLabel} - Reported "suite-failed-early" task update for "${fileTask.filepath}"`);
+}
+/** Report suite-prepare event */
+async function reportSuitePrepare(rpc, suite, logModule, base) {
+	const taskPack = [
+		suite.id,
+		suite.result,
+		{}
+	];
+	const eventPack = [
+		suite.id,
+		"suite-prepare",
+		void 0
+	];
+	await rpc.onTaskUpdate([taskPack], [eventPack]);
+	rpcDebug(`[${logModule} RPC] ${getTaskLogLabel(base, suite)} - Reported "suite-prepare" task update | state: "${suite.result?.state}"`);
+}
+/** Report suite-finished event */
+async function reportSuiteFinished(rpc, suite, logModule, base, vitestVersion = "v4") {
+	const suiteLabel = getTaskLogLabel(base, suite);
+	const rpcLogPrefix = `[${logModule} RPC] ${suiteLabel}`;
+	const meta = suite.meta;
+	const coverageKeys = Object.keys(meta.coverageData?.hitCountsByFileAndPosition ?? {}).length;
+	let coveragePromise = Promise.resolve();
+	if (isSuiteOwnFile(suite) && coverageKeys > 0) {
+		const afterSuiteMeta = createAfterSuiteRunMeta({
+			__format: COVERAGE_PAYLOAD_FORMATS.AssemblyScript,
+			coverageData: meta.coverageData,
+			suiteLogLabel: suiteLabel
+		}, [suite.file.filepath], suite.file.projectName, vitestVersion);
+		coveragePromise = rpc.onAfterSuiteRun(afterSuiteMeta);
+		debug(`${rpcLogPrefix} - onAfterSuiteRun: Reported suite coverage (${coverageKeys} unique positions)`);
+	} else if (coverageKeys === 0) debug(`${rpcLogPrefix} - onAfterSuiteRun: No suite coverage to report`);
+	const taskPack = [
+		suite.id,
+		suite.result,
+		{}
+	];
+	const eventPack = [
+		suite.id,
+		"suite-finished",
+		void 0
+	];
+	await Promise.all([coveragePromise, rpc.onTaskUpdate([taskPack], [eventPack])]);
+	rpcDebug(`${rpcLogPrefix} - Reported "suite-finished" task update | state: "${suite.result?.state}" | duration: ${suite.result?.duration?.toFixed(2) ?? "--"} ms`);
+}
+async function reportTestTaskUpdate(rpc, test, logModule, base, updateEvent) {
+	const taskPack = [
+		test.id,
+		test.result,
+		{}
+	];
+	const eventPack = [
+		test.id,
+		updateEvent,
+		void 0
+	];
+	rpcDebug(`[${logModule} RPC] ${getTaskLogLabel(base, test)} - Reporting "${updateEvent}" task update... | state: "${test.result?.state}"${updateEvent === "test-prepare" ? "" : ` | duration: ${test.result?.duration?.toFixed(2) ?? "--"} ms`}`);
+	await rpc.onTaskUpdate([taskPack], [eventPack]);
+	rpcDebug(`[${logModule} RPC] ${getTaskLogLabel(base, test)} - Reported "${updateEvent}" task update | state: "${test.result?.state}"${updateEvent === "test-prepare" ? "" : ` | duration: ${test.result?.duration?.toFixed(2) ?? "--"} ms`}`);
+}
+/** Report test starting execution */
+async function reportTestPrepare(rpc, test, logModule, base) {
+	return reportTestTaskUpdate(rpc, test, logModule, base, "test-prepare");
+}
+/** Report test finished execution */
+async function reportTestFinished(rpc, test, logModule, base) {
+	return reportTestTaskUpdate(rpc, test, logModule, base, "test-finished");
+}
+/** Report test retried (sent when test failed and is going to be retried) */
+async function reportTestRetried(rpc, test, logModule, base) {
+	return reportTestTaskUpdate(rpc, test, logModule, base, "test-retried");
+}
+/** Report user console log messages */
+async function reportUserConsoleLogs(rpc, logs, logModule, base, task) {
+	if (logs.length === 0) return;
+	const stdLogs = logs.filter((l) => !l.isError);
+	const errorLogs = logs.filter((l) => l.isError);
+	const stdContent = stdLogs.map((l) => `${l.msg}`).join("\n");
+	const errorContent = errorLogs.filter((l) => l.isError).map((l) => `${l.msg}`).join("\n");
+	const stdLog = {
+		content: `${stdContent}\n`,
+		size: stdContent.length,
+		browser: false,
+		type: "stdout",
+		time: stdLogs.length > 0 ? stdLogs[0].time : Date.now(),
+		taskId: task.id,
+		origin: task.id
+	};
+	const errorLog = {
+		content: `${errorContent}\n`,
+		size: errorContent.length,
+		browser: false,
+		type: "stderr",
+		time: errorLogs.length > 0 ? errorLogs[0].time : Date.now(),
+		taskId: task.id,
+		origin: task.id
+	};
+	const reportPromises = [];
+	if (stdContent.length > 0) reportPromises.push(rpc.onUserConsoleLog(stdLog));
+	if (errorContent.length > 0) reportPromises.push(rpc.onUserConsoleLog(errorLog));
+	await Promise.all(reportPromises);
+	rpcDebug(`[${logModule} RPC] ${getTaskLogLabel(base, task)} - Reported onUserConsoleLog | ${logs.length} messages`);
+}
+/** Flush any pending RPC updates */
+async function flushRpcUpdates(rpc) {
+	await rpc.onTaskUpdate([], []);
+}
+
+//#endregion
+//#region src/pool-thread/load-user-imports.ts
+async function loadUserWasmImportsFactory(relativePath, projectRoot, logModule) {
+	if (!relativePath) return;
+	const path = resolve(projectRoot, relativePath);
+	try {
+		const start = performance.now();
+		const createWasmImports = (await import(path)).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;
+	} catch (error) {
+		if (error["__as_pool__"]) throw error;
+		throw new Error(`Could not load user WasmImportsFactory from "${path}". 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 });
+	}
+}
+
+//#endregion
+export { createRpcClient, executeWASMDiscovery, executeWASMTest, flushRpcUpdates, loadUserWasmImportsFactory, reportFileCollected, reportFileError, reportFileQueued, reportSuiteFinished, reportSuitePrepare, reportTestFinished, reportTestPrepare, reportTestRetried, reportUserConsoleLogs };
+//# sourceMappingURL=load-user-imports-J9eaAW0_.mjs.map