vitest-pool-assemblyscript 0.9.1 → 0.10.1

package/dist/pool-errors-Bn6YaguR.mjs

@@ -0,0 +1,630 @@
+import { POOL_ERROR_NAMES, POOL_INTERNAL_PATHS, TEST_ERROR_NAMES } from "./constants-Bq5KNxXJ.mjs";
+import { relative } from "node:path";
+import { readFile } from "node:fs/promises";
+import { stripVTControlCharacters } from "node:util";
+import c from "tinyrainbow";
+import { highlight } from "tinyhighlight";
+import { fileURLToPath } from "node:url";
+import { diff } from "@vitest/utils/diff";
+import { SourceMapConsumer } from "source-map";
+
+//#region src/util/path-utils.ts
+/**
+* Path Utilities
+*
+* Cross-platform path normalization for consistent path comparisons.
+* All internal paths use forward slashes.
+*/
+/**
+* Convert path to forward slashes for consistent cross-platform comparison.
+*
+* Source maps always use forward slashes regardless of OS. By normalizing
+* all paths to forward slashes, we ensure consistent matching between:
+* - Source map paths (already forward slashes)
+* - Glob results (OS-native, need conversion on Windows)
+* - Relative paths from Node's path.relative() (OS-native)
+* - Resolved paths from Node's path.resolve() (OS-native)
+*/
+function toForwardSlash(path) {
+	return path.replace(/\\/g, "/");
+}
+
+//#endregion
+//#region src/util/debug.ts
+globalThis.AS_POOL_DEBUG = false;
+const DEBUG_ENV_ENABLED_VALUE = "vitest_as_pool";
+function isEnabled() {
+	return globalThis.AS_POOL_DEBUG === true || process.env.DEBUG === DEBUG_ENV_ENABLED_VALUE;
+}
+/**
+* Initialize debug mode for current async context (called by worker at task start)
+* @param {boolean} debugEnabled - Enable verbose debug logging
+*/
+function setGlobalDebugMode(debugEnabled) {
+	globalThis.AS_POOL_DEBUG = debugEnabled;
+}
+function debugLog(...args) {
+	if (args?.length > 0 && typeof args[0] === "function") {
+		const result = args[0]();
+		const rest = args.length > 1 ? args.slice(1) : [];
+		console.log(Date.now(), String(result), ...rest);
+	} else console.log(Date.now(), ...args);
+}
+/**
+* Log debug message (only when debug enabled in current global context)
+* or when environment has a given DEBUG variable set.
+*/
+function debug(...args) {
+	if (isEnabled()) debugLog(...args);
+}
+/**
+* Log debug message (caller expected to determine if enabled)
+*/
+function debugOverride(...args) {
+	debugLog(...args);
+}
+
+//#endregion
+//#region src/util/highlight-code.ts
+/**
+* Adapted from vitest. The internal function was changed between vitest 3.2.x and 4.0.x,
+* and then removed from public exposure in 4.1.x, so now instead we recreate the same
+* highlighting color rules.
+* 
+* @see https://github.com/vitest-dev/vitest/blob/v4.1.0/packages/vitest/src/utils/colors.ts#L18
+* 
+* Vitest is released under the MIT license, included in this project's root.
+* Copyright (c) 2021-Present Vitest Team
+*/
+const colors = {
+	Keyword: c.magenta,
+	IdentifierCapitalized: c.yellow,
+	Punctuator: c.yellow,
+	StringLiteral: c.green,
+	NoSubstitutionTemplate: c.green,
+	MultiLineComment: c.gray,
+	SingleLineComment: c.gray,
+	RegularExpressionLiteral: c.cyan,
+	NumericLiteral: c.blue,
+	TemplateHead: (text) => c.green(text.slice(0, text.length - 2)) + c.cyan(text.slice(-2)),
+	TemplateTail: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1)),
+	TemplateMiddle: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1, text.length - 2)) + c.cyan(text.slice(-2)),
+	IdentifierCallable: c.blue,
+	PrivateIdentifierCallable: (text) => `#${c.blue(text.slice(1))}`,
+	Invalid: (text) => c.white(c.bgRed(c.bold(text)))
+};
+function highlightCode(source) {
+	return highlight(source, { colors });
+}
+
+//#endregion
+//#region src/util/test-error-formatting.ts
+const FRAME_POINTER = "❯";
+const CODE_FRAME_INDENT_SPACES = 4;
+const MAX_CODE_HIGHLIGHT_LENGTH = 1e5;
+function getYellowString(str) {
+	return c.yellow(str);
+}
+function toPlaintextStackFrameString(frame) {
+	return `    at ${frame.method} ${frame.file}:${frame.line}:${frame.column}`;
+}
+function toVitestLikeStackFrameString(frame) {
+	return c.cyan(` ${c.dim(FRAME_POINTER)} ${frame.method} ${frame.file}:${c.dim(`${frame.line}:${frame.column}`)}`);
+}
+async function getSourceCodeFrameString(sourceMap, frame) {
+	let source;
+	const fileIndex = sourceMap?.sources.indexOf(frame.file) ?? -1;
+	if (fileIndex < 0 || !sourceMap?.sourcesContent) source = await readFile(frame.file, "utf-8");
+	else source = sourceMap.sourcesContent[fileIndex];
+	if (!source) return;
+	return generateCodeFrame(source.length < MAX_CODE_HIGHLIGHT_LENGTH ? highlightCode(source) : source, CODE_FRAME_INDENT_SPACES, frame);
+}
+/**
+* Vitest doesn't expose generateCodeFrame as a util, so we have
+* recreated it here with minimal changes.
+* 
+* @see https://github.com/vitest-dev/vitest/blob/v3.2.4/packages/vitest/src/node/printError.ts#L424
+* 
+* Vitest is released under the MIT license, included in this project's root.
+* Copyright (c) 2021-Present Vitest Team
+*/
+const lineSplitRE = /\r?\n/;
+function generateCodeFrame(source, indent = 0, loc, range = 2) {
+	const start = typeof loc === "object" ? positionToOffset(source, loc.line, loc.column) : loc;
+	const end = start;
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let count = 0;
+	let res = [];
+	const columns = process.stdout?.columns || 80;
+	for (let i = 0; i < lines.length; i++) {
+		count += lines[i].length + nl;
+		if (count >= start) {
+			for (let j = i - range; j <= i + range || end > count; j++) {
+				if (j < 0 || j >= lines.length) continue;
+				const lineLength = lines[j].length;
+				if (stripVTControlCharacters(lines[j]).length > 200) return "";
+				res.push(lineNo(j + 1) + truncateString(lines[j].replace(/\t/g, " "), columns - 5 - indent));
+				if (j === i) {
+					const pad = start - (count - lineLength) + (nl - 1);
+					const length = Math.max(1, end > count ? lineLength - pad : end - start);
+					res.push(lineNo() + " ".repeat(pad) + c.red("^".repeat(length)));
+				} else if (j > i) {
+					if (end > count) {
+						const length = Math.max(1, Math.min(end - count, lineLength));
+						res.push(lineNo() + c.red("^".repeat(length)));
+					}
+					count += lineLength + 1;
+				}
+			}
+			break;
+		}
+	}
+	if (indent) res = res.map((line) => " ".repeat(indent) + line);
+	return res.join("\n");
+}
+function positionToOffset(source, lineNumber, columnNumber) {
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let start = 0;
+	if (lineNumber > lines.length) return source.length;
+	for (let i = 0; i < lineNumber - 1; i++) start += lines[i].length + nl;
+	return start + columnNumber;
+}
+function lineNo(no = "") {
+	return c.gray(`${String(no).padStart(3, " ")}| `);
+}
+function truncateString(text, maxLength) {
+	const plainText = stripVTControlCharacters(text);
+	if (plainText.length <= maxLength) return text;
+	return `${plainText.slice(0, maxLength - 1)}…`;
+}
+
+//#endregion
+//#region src/wasm-executor/source-maps.ts
+function parseSourceMap(sourceMap) {
+	const sourceMapObj = JSON.parse(sourceMap);
+	delete sourceMapObj.sourceRoot;
+	return sourceMapObj;
+}
+/**
+* Extract structured call stack from V8 using Error.prepareStackTrace
+*
+* V8 provides a special API to access structured stack traces with line:column info.
+* This gives us WAT text positions which can be mapped to AS source via source maps.
+*
+* @param capturedError - Error object to extract stack from
+* @returns Array of V8 CallSite objects
+*/
+function extractCallStack(capturedError) {
+	let stackTrace = [];
+	const originalPrepareStackTrace = Error.prepareStackTrace;
+	Error.prepareStackTrace = (_err, structuredStackTrace) => {
+		stackTrace = structuredStackTrace;
+		return "";
+	};
+	capturedError.stack;
+	Error.prepareStackTrace = originalPrepareStackTrace;
+	return stackTrace;
+}
+/**
+* Create WebAssembly call site with source mapping
+*
+* Takes a V8 CallSite and maps it to AS source location if possible.
+*
+* @param callSite - V8 CallSite object from Error.prepareStackTrace
+* @param sourceMapJson - Source map consumer initialized with WASM source map
+* @returns Mapped call site or null if not a WASM call site
+*/
+function createWebAssemblyCallSite(callSite, sourceMapConsumer, loggingPrefix, allowJS) {
+	const fileName = callSite.getFileName();
+	const watLine = callSite.getLineNumber();
+	const watColumn = callSite.getColumnNumber();
+	const functionName = callSite.getFunctionName() ?? "function[unknown]";
+	const debugString = `function: "${functionName}" | file: ${fileName}:${watLine}:${watColumn}`;
+	if (!fileName) {
+		debug(`${loggingPrefix} - Skipping source-mapping of invalid frame (no file): ${debugString}`);
+		return null;
+	}
+	if (!fileName.startsWith("wasm://")) if (allowJS) {
+		if (!watLine || !watColumn) {
+			debug(`${loggingPrefix} - Failed to pass through invalid JS stack location: ${debugString}`);
+			return null;
+		}
+		debug(`${loggingPrefix} - Passing through JS stack location: ${debugString}`);
+		return {
+			functionName,
+			location: {
+				filePath: fileName,
+				line: watLine,
+				column: watColumn
+			}
+		};
+	} else {
+		debug(`${loggingPrefix} - Skipping source-mapping of non-WASM stack location: ${debugString}`);
+		return null;
+	}
+	if (watLine && watColumn) {
+		const original = sourceMapConsumer.originalPositionFor({
+			line: watLine,
+			column: watColumn
+		});
+		if (!original.source || original.line === null || original.column === null) {
+			debug(`${loggingPrefix} - Failed to source-map stack location: ${debugString}`);
+			return null;
+		}
+		debug(`${loggingPrefix} - Source-mapped stack location: ${debugString}  →  ${original.source}:${original.line}:${original.column}`);
+		return {
+			functionName,
+			location: {
+				filePath: original.source,
+				line: original.line,
+				column: original.column
+			}
+		};
+	}
+	debug(`${loggingPrefix} - Cannot source-map stack-location: ${debugString}`);
+	return null;
+}
+
+//#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);
+		decoded = decoded.replace("\\2c", ",");
+	} 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
+/**
+* Error Enhancement and Source Mapping
+*
+* This module handles mapping WASM errors to AssemblyScript source locations
+* using source maps. It enhances error messages and stack traces with accurate
+* file:line:column information for better developer experience.
+*/
+const POOL_INTERNAL_PATHS_SET = new Set(POOL_INTERNAL_PATHS);
+function passthroughCallSite(callSite) {
+	const fileName = callSite.getFileName();
+	const watLine = callSite.getLineNumber();
+	const watColumn = callSite.getColumnNumber();
+	return {
+		method: callSite.getFunctionName() || "wasm-function[unknown]",
+		file: fileName ?? "unknown-file",
+		line: watLine || -1,
+		column: watColumn || -1
+	};
+}
+async function sourceMapRawCallStack(rawCallStack, sourceMap, loggingPrefix, allowJS) {
+	const mappedStack = [];
+	if (!rawCallStack || rawCallStack.length === 0) return mappedStack;
+	if (sourceMap) {
+		const sourceMapConsumer = await new SourceMapConsumer(sourceMap);
+		rawCallStack.forEach((callSite) => {
+			const mappedCallSite = createWebAssemblyCallSite(callSite, sourceMapConsumer, loggingPrefix, allowJS);
+			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.filePath.startsWith("file") ? frame.location.column : frame.location.column + 1
+	}));
+}
+async function processWASMErrorStack(rawCallStack, sourceMap, loggingPrefix, allowJS) {
+	const sourceMappedStack = await sourceMapRawCallStack(rawCallStack, sourceMap, loggingPrefix, allowJS);
+	debug(`${loggingPrefix} - Mapped ${rawCallStack.length} call sites to ${sourceMappedStack.length} source locations`);
+	const parsedStack = parseMappedStack(sourceMappedStack);
+	if (parsedStack.length === 0) rawCallStack.forEach((callSite) => {
+		parsedStack.push(passthroughCallSite(callSite));
+	});
+	return parsedStack;
+}
+/**
+* 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(testError, task, sourceMap, logPrefix, allowJS, projectRoot, applyStackToTestErrorCause, rawCallStack, diffOptions) {
+	let expectedVsActualDiffString;
+	const isAssertionFailure = testError.name === TEST_ERROR_NAMES.AssertionError;
+	const valuesProvided = testError.expected !== void 0 && testError.actual !== void 0;
+	if (isAssertionFailure && valuesProvided) expectedVsActualDiffString = diff(testError.expected, testError.actual, diffOptions) ?? "";
+	if (!rawCallStack || rawCallStack.length === 0) {
+		testError.diff = expectedVsActualDiffString;
+		testError.stack = `${task.name} - ${testError.message}`;
+		return;
+	}
+	const testErrorToUpdate = applyStackToTestErrorCause && testError.cause ? testError.cause : testError;
+	const parsedStack = await processWASMErrorStack(rawCallStack, sourceMap, logPrefix, allowJS);
+	let primaryStackFrameString;
+	let highlightedSourceCodeFrameString;
+	if (parsedStack.length > 0) {
+		parsedStack.forEach((frame) => {
+			if (frame.file.startsWith("file://")) {
+				frame.file = toForwardSlash(relative(projectRoot, fileURLToPath(frame.file)));
+				testErrorToUpdate.stack += toPlaintextStackFrameString(frame) + "\n";
+			}
+		});
+		const primaryStackFrame = parsedStack[0];
+		testErrorToUpdate.stacks = parsedStack.slice(1);
+		testErrorToUpdate.stack = parsedStack.map(toPlaintextStackFrameString).join("\n");
+		try {
+			highlightedSourceCodeFrameString = await getSourceCodeFrameString(sourceMap, primaryStackFrame);
+		} catch (err) {
+			debug(`${logPrefix} - Error reading source for primary stack frame file "${primaryStackFrame.file}":`, err);
+		}
+		primaryStackFrameString = toVitestLikeStackFrameString(primaryStackFrame);
+		debug(`${logPrefix} - Enhanced ${testError.name} error with parsed source stack`);
+	} else testErrorToUpdate.stack = `${task.name} - ${testError.message}`;
+	testErrorToUpdate.diff = [
+		expectedVsActualDiffString,
+		expectedVsActualDiffString ? "\n\n" : "",
+		primaryStackFrameString ?? "",
+		highlightedSourceCodeFrameString ? "\n" : "",
+		highlightedSourceCodeFrameString ?? ""
+	].join("");
+	debug(`[${logPrefix} - Enhanced error with diffs`);
+}
+
+//#endregion
+//#region src/util/pool-errors.ts
+function abortWASMExecutionOnSuccess() {
+	return {
+		["__as_pool_error__"]: true,
+		name: POOL_ERROR_NAMES.WASMExecutionAbortSuccess,
+		testError: {},
+		originalErrorMayContainJS: false,
+		originalErrorRawStack: [],
+		applyStackToTestErrorCause: false
+	};
+}
+function abortWASMExecution(testError, errorForStack) {
+	return {
+		["__as_pool_error__"]: true,
+		name: POOL_ERROR_NAMES.WASMExecutionAbortError,
+		testError,
+		originalErrorMayContainJS: false,
+		originalErrorRawStack: errorForStack ? extractCallStack(errorForStack) : [],
+		applyStackToTestErrorCause: false
+	};
+}
+function wrapPoolError(name, originalError, originalErrorMayContainJS = false) {
+	let originalErrorName;
+	let originalErrorMessage;
+	let originalErrorRawStack;
+	if (originalError && originalError instanceof Error) {
+		originalErrorName = originalError.name;
+		originalErrorMessage = originalError.message;
+		originalErrorRawStack = extractCallStack(originalError);
+	} else if (originalError) {
+		originalErrorMessage = String(originalError);
+		originalErrorRawStack = [];
+	} else {
+		originalErrorMessage = "Unknown Error";
+		originalErrorRawStack = [];
+	}
+	const testError = {
+		name,
+		message: `${originalErrorName ? `${originalErrorName}: ` : ""}${originalErrorMessage}`
+	};
+	return {
+		["__as_pool_error__"]: true,
+		name,
+		message: "Wrapped error",
+		originalErrorRawStack,
+		originalErrorMayContainJS,
+		testError,
+		applyStackToTestErrorCause: false
+	};
+}
+function createPoolError(name, message, originalError, originalErrorMayContainJS = true) {
+	if (originalError && originalError["__as_pool_error__"]) return originalError;
+	let originalErrorRawStack = [];
+	let applyStackToTestErrorCause = false;
+	const testError = {
+		name,
+		message
+	};
+	if (originalError && originalError instanceof Error) {
+		testError.cause = {
+			name: originalError.name,
+			message: `${originalError.message}`
+		};
+		originalErrorRawStack = extractCallStack(originalError);
+		applyStackToTestErrorCause = true;
+	} else if (originalError) testError.cause = {
+		name: POOL_ERROR_NAMES.PoolError,
+		message: String(originalError)
+	};
+	return {
+		["__as_pool_error__"]: true,
+		name,
+		message,
+		originalErrorRawStack,
+		originalErrorMayContainJS,
+		testError,
+		applyStackToTestErrorCause
+	};
+}
+function createTestTimeoutError(test) {
+	const message = `Test timed out after ${test.timeout}ms`;
+	return {
+		name: POOL_ERROR_NAMES.WASMExecutionTimeoutError,
+		message,
+		stack: `${test.id}_${message}`,
+		diff: getYellowString(` Test Timeout Exceeded (${test.timeout}ms)`)
+	};
+}
+function createTestExpectedToFailError(test) {
+	const message = `Test is expected to fail, but all assertion(s) passed`;
+	return {
+		name: TEST_ERROR_NAMES.AssertionError,
+		message,
+		stack: `${test.id}_${message}`,
+		diff: getYellowString(` Expected to fail, but all assertion(s) passed`)
+	};
+}
+function isAbortErrorString(item) {
+	return item === POOL_ERROR_NAMES.PoolRunAbortedError || item === "AbortError";
+}
+function isAbortError(error) {
+	return isAbortErrorString(error) || isAbortErrorString(error?.name) || error?.message === "Terminating worker thread";
+}
+function getExpectedMessageOrAny(expectedMsgStr) {
+	return expectedMsgStr ? `"${expectedMsgStr}"` : "<any>";
+}
+async function buildEnhancedFileError(error, task, sourceMap, logPrefix, projectRoot, unexpectedContext, diffOptions) {
+	let testError;
+	let stack;
+	let applyStackToTestErrorCause;
+	let allowStackJS;
+	if (error && error["__as_pool_error__"]) {
+		const wrapper = error;
+		testError = wrapper.testError;
+		stack = wrapper.originalErrorRawStack;
+		applyStackToTestErrorCause = wrapper.applyStackToTestErrorCause;
+		allowStackJS = wrapper.originalErrorMayContainJS;
+	} else if (error instanceof Error) {
+		testError = {
+			name: POOL_ERROR_NAMES.PoolError,
+			message: `${error.name}: ${error.message}`
+		};
+		stack = extractCallStack(error);
+		allowStackJS = true;
+		applyStackToTestErrorCause = false;
+	} else {
+		testError = {
+			name: POOL_ERROR_NAMES.PoolError,
+			message: `Unexpected error (${unexpectedContext}): ${String(error)}`
+		};
+		stack = extractCallStack(/* @__PURE__ */ new Error());
+		allowStackJS = true;
+		applyStackToTestErrorCause = false;
+	}
+	await enhanceTestError(testError, task, sourceMap, logPrefix, allowStackJS, projectRoot, applyStackToTestErrorCause, stack, diffOptions);
+	return testError;
+}
+
+//#endregion
+export { abortWASMExecution, abortWASMExecutionOnSuccess, buildEnhancedFileError, createPoolError, createTestExpectedToFailError, createTestTimeoutError, debug, debugOverride, enhanceTestError, extractCallStack, getExpectedMessageOrAny, getShortFunctionName, isAbortError, parseSourceMap, setGlobalDebugMode, toForwardSlash, wrapPoolError };
+//# sourceMappingURL=pool-errors-Bn6YaguR.mjs.map