vitest-pool-assemblyscript 0.2.0

package/dist/coverage-merge-0WqdC-dq.mjs

@@ -0,0 +1,22 @@
+//#region src/coverage-provider/coverage-merge.ts
+/**
+* Merge incoming CoverageData into accumulated CoverageData
+*
+* Combines by filepath + position, summing hit counts.
+* Mutates the accumulated object in place.
+*
+* @param accumulated - Accumulated coverage data (mutated)
+* @param incoming - New coverage data to merge in
+*/
+function mergeCoverageData(accumulated, incoming) {
+	for (const [filePath, positions] of Object.entries(incoming.hitCountsByFileAndPosition)) {
+		if (!accumulated.hitCountsByFileAndPosition[filePath]) accumulated.hitCountsByFileAndPosition[filePath] = {};
+		const accumulatedPositions = accumulated.hitCountsByFileAndPosition[filePath];
+		for (const [positionKey, hitCount] of Object.entries(positions)) if (accumulatedPositions[positionKey] !== void 0) accumulatedPositions[positionKey] += hitCount;
+		else accumulatedPositions[positionKey] = hitCount;
+	}
+}
+
+//#endregion
+export { mergeCoverageData };
+//# sourceMappingURL=coverage-merge-0WqdC-dq.mjs.map

package/dist/coverage-merge-0WqdC-dq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-merge-0WqdC-dq.mjs","names":[],"sources":["../src/coverage-provider/coverage-merge.ts"],"sourcesContent":["/**\n * Coverage Data Merge Utilities\n *\n * Functions for merging CoverageData objects\n */\n\nimport type { CoverageData } from '../types/types.js';\n\n/**\n * Merge incoming CoverageData into accumulated CoverageData\n *\n * Combines by filepath + position, summing hit counts.\n * Mutates the accumulated object in place.\n *\n * @param accumulated - Accumulated coverage data (mutated)\n * @param incoming - New coverage data to merge in\n */\nexport function mergeCoverageData(\n  accumulated: CoverageData,\n  incoming: CoverageData\n): void {\n  for (const [filePath, positions] of Object.entries(incoming.hitCountsByFileAndPosition)) {\n    // Ensure file exists in accumulated\n    if (!accumulated.hitCountsByFileAndPosition[filePath]) {\n      accumulated.hitCountsByFileAndPosition[filePath] = {};\n    }\n\n    const accumulatedPositions = accumulated.hitCountsByFileAndPosition[filePath];\n\n    for (const [positionKey, hitCount] of Object.entries(positions)) {\n      if (accumulatedPositions[positionKey] !== undefined) {\n        // Position exists - sum hit counts\n        accumulatedPositions[positionKey] += hitCount;\n      } else {\n        // New position - set hit count\n        accumulatedPositions[positionKey] = hitCount;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAiBA,SAAgB,kBACd,aACA,UACM;AACN,MAAK,MAAM,CAAC,UAAU,cAAc,OAAO,QAAQ,SAAS,2BAA2B,EAAE;AAEvF,MAAI,CAAC,YAAY,2BAA2B,UAC1C,aAAY,2BAA2B,YAAY,EAAE;EAGvD,MAAM,uBAAuB,YAAY,2BAA2B;AAEpE,OAAK,MAAM,CAAC,aAAa,aAAa,OAAO,QAAQ,UAAU,CAC7D,KAAI,qBAAqB,iBAAiB,OAExC,sBAAqB,gBAAgB;MAGrC,sBAAqB,eAAe"}

package/dist/coverage-provider/index.d.mts

@@ -0,0 +1,15 @@
+import { CoverageProviderModule } from "vitest/node";
+
+//#region src/coverage-provider/index.d.ts
+/**
+* Hybrid Coverage Provider
+*
+* This provider handles both AssemblyScript and JavaScript and coverage
+* - Converts AS coverage to Istanbul format
+* - Delegates JS coverage to Vitest's v8 provider
+* - Merges both into a unified coverage report
+*/
+declare const hybridProviderModule: CoverageProviderModule;
+//#endregion
+export { hybridProviderModule as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/coverage-provider/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/coverage-provider/index.ts"],"mappings":";;;;;;;;;;;cAwBM,oBAAA,EAAsB,sBAAA"}

package/dist/coverage-provider/index.mjs

@@ -0,0 +1,535 @@
+import { ASCommonFlags, ASNodeKind, COVERAGE_PAYLOAD_FORMATS, POOL_ERROR_NAMES } from "../constants-CA50WBdr.mjs";
+import { getProjectSerializedOrGlobalConfig } from "../resolve-config-as1w-Qyz.mjs";
+import { createPoolError, debug } from "../debug-IeEHsxy0.mjs";
+import { mergeCoverageData } from "../coverage-merge-0WqdC-dq.mjs";
+import { ASTVisitor } from "../ast-visitor-DC3SuTzs.mjs";
+import { basename, parse, relative } from "node:path";
+import { readFile } from "node:fs/promises";
+import v8CoverageModule from "@vitest/coverage-v8";
+import { createCoverageMap } from "istanbul-lib-coverage";
+import { Parser } from "assemblyscript";
+import { resolve as resolve$1 } from "path";
+import TestExclude from "test-exclude";
+
+//#region src/coverage-provider/containment-matcher.ts
+/**
+* Find the source function whose range contains the given position.
+*
+* For nested functions, uses "tightest fit" - returns the innermost function
+* (the one with the largest start position among all containing functions).
+*
+* @param functionsByStartLine - Functions for a single file, indexed by start line
+* @param line - Target line number (1-based)
+* @param column - Target column number (1-based)
+* @returns The containing function, or undefined if no match
+*/
+function findFunctionContainingPosition(functionsByStartLine, line, column) {
+	let bestMatch;
+	let bestStartLine = -1;
+	let bestStartColumn = -1;
+	for (const [startLineStr, functions] of Object.entries(functionsByStartLine)) {
+		const startLine = Number(startLineStr);
+		if (startLine > line) continue;
+		for (const func of functions) {
+			const { range } = func;
+			if (!isPositionInRange(line, column, range)) continue;
+			if (startLine > bestStartLine || startLine === bestStartLine && range.startColumn > bestStartColumn) {
+				bestMatch = func;
+				bestStartLine = startLine;
+				bestStartColumn = range.startColumn;
+			}
+		}
+	}
+	return bestMatch;
+}
+/**
+* Check if a position (line, column) falls within a source range.
+*
+* @param line - Target line number (1-based)
+* @param column - Target column number (1-based)
+* @param range - Source range to check against
+* @returns true if position is within range (inclusive)
+*/
+function isPositionInRange(line, column, range) {
+	if (line < range.startLine || line > range.endLine) return false;
+	if (line === range.startLine && column < range.startColumn) return false;
+	if (line === range.endLine && column > range.endColumn) return false;
+	return true;
+}
+
+//#endregion
+//#region src/coverage-provider/istanbul-converter.ts
+function istanbulDebug(...args) {}
+/**
+* Convert AssemblyScript coverage data to Istanbul format for a single file
+*
+* Algorithm (containment matching):
+* 1. For each hit position in fileHitCountsByPosition:
+*    - Use containment matcher to find which source function contains this position
+*    - Record the hit count for that function
+* 2. For each function in fileFunctionsByStartLine:
+*    - Add function mapping to fnMap
+*    - Add function hit count to f (from matched hits, or 0 if not hit)
+*    - Add corresponding statement mapping to statementMap
+*    - Add same hit count to s (statement coverage matches function coverage)
+*
+* @param fileFunctionsByStartLine - Functions for this file, keyed by start line (from AST parser)
+* @param fileHitCountsByPosition - Hit counts for this file, keyed by position "line:column" (from accumulated coverage)
+* @param absoluteFilePath - Absolute path to the source file (for Istanbul output)
+* @returns Istanbul FileCoverage object
+*/
+async function convertToIstanbulFormat(fileFunctionsByStartLine, fileHitCountsByPosition, absoluteFilePath) {
+	const startMatch = performance.now();
+	istanbulDebug(() => {
+		const sourceFunctionCount = Object.values(fileFunctionsByStartLine).reduce((sum, funcs) => sum + funcs.length, 0);
+		const uniqueHitPosCount = Object.keys(fileHitCountsByPosition).length;
+		return `[IstanbulConverter]   Processing source file: "${absoluteFilePath}"\n[IstanbulConverter]   Source: ${sourceFunctionCount} total functions, Coverage: ${uniqueHitPosCount} unique hit positions\n[IstanbulConverter]   Sanity Check - AS File Coverage Estimate: ${sourceFunctionCount === 0 ? Infinity : (uniqueHitPosCount * 100 / sourceFunctionCount).toFixed(2)}%\n[IstanbulConverter]   Containment matching functions: coverage hit positions to source functions by range`;
+	});
+	const hitCountsBySourceFunctionName = /* @__PURE__ */ new Map();
+	for (const [positionKey, hitCount] of Object.entries(fileHitCountsByPosition)) {
+		const parts = positionKey.split(":");
+		const lineStr = parts[0];
+		const columnStr = parts[1];
+		if (lineStr && columnStr) {
+			const containingFunction = findFunctionContainingPosition(fileFunctionsByStartLine, parseInt(lineStr, 10), parseInt(columnStr, 10));
+			if (containingFunction) {
+				const existingHits = hitCountsBySourceFunctionName.get(containingFunction);
+				const existingHitsCount = existingHits ?? 0;
+				const max = Math.max(existingHitsCount, hitCount);
+				hitCountsBySourceFunctionName.set(containingFunction, max);
+				if (existingHits !== void 0) istanbulDebug(`[IstanbulConverter]     Position ${positionKey} → function "${containingFunction.shortName}" EXISTING HITS: ${existingHits} NEW COUNT: ${max}`);
+				else istanbulDebug(`[IstanbulConverter]     Position ${positionKey} → function "${containingFunction.shortName}" (hits: ${hitCount})`);
+			} else istanbulDebug(`[IstanbulConverter]     Position ${positionKey} has no containing function`);
+		}
+	}
+	const startConvert = performance.now();
+	istanbulDebug(`[IstanbulConverter]   Matching Complete - Converting to Istanbul format`);
+	const fnMap = {};
+	const f = {};
+	const statementMap = {};
+	const s = {};
+	const branchMap = {};
+	const b = {};
+	let funcIdx = 0;
+	for (const functions of Object.values(fileFunctionsByStartLine)) for (const funcInfo of functions) {
+		const { range, shortName } = funcInfo;
+		if (range.startLine === 0) continue;
+		const hitCount = hitCountsBySourceFunctionName.get(funcInfo) ?? 0;
+		istanbulDebug(`[IstanbulConverter]     Istanbul function index ${funcIdx}: "${shortName && shortName !== "" ? shortName : "<anonymous>"}" (source ${range.startLine}:${range.startColumn} - ${range.endLine}:${range.endColumn}), hits: ${hitCount}`);
+		const istanbulRange = {
+			start: {
+				line: range.startLine,
+				column: range.startColumn - 1
+			},
+			end: {
+				line: range.endLine,
+				column: range.endColumn - 1
+			}
+		};
+		const idxStr = funcIdx.toString();
+		fnMap[idxStr] = {
+			name: shortName,
+			decl: istanbulRange,
+			loc: istanbulRange,
+			line: range.startLine
+		};
+		f[idxStr] = hitCount;
+		statementMap[idxStr] = istanbulRange;
+		s[idxStr] = hitCount;
+		funcIdx++;
+	}
+	const done = performance.now();
+	const matchingMs = (startConvert - startMatch).toFixed(2);
+	const convertMs = (done - startConvert).toFixed(2);
+	const totalMs = (done - startMatch).toFixed(2);
+	istanbulDebug(`[IstanbulConverter]   Coverage Coversion Complete: ${Object.keys(fnMap).length} functions, ${totalMs} ms total (matching: ${matchingMs} ms, convert: ${convertMs} ms)`);
+	return {
+		path: absoluteFilePath,
+		fnMap,
+		f,
+		statementMap,
+		s,
+		branchMap,
+		b
+	};
+}
+
+//#endregion
+//#region src/coverage-provider/ast-parser.ts
+/**
+* AST Parser for AssemblyScript Source Files
+*
+* Parses AS source files to extract function metadata for coverage.
+* Used by generateCoverage to build empty coverage map from all source files.
+*
+* Source AST is the source of truth for what SHOULD be covered.
+* Binary instrumentation tells us what we CAN measure (hit counts).
+*
+* Functions are grouped by start line for efficient containment matching.
+*
+* Architecture:
+* - Uses shared ASTVisitor for complete NodeKind coverage
+* - Overrides hooks to extract function information during traversal
+*/
+/**
+* Visitor that extracts function information from AST nodes
+*/
+var FunctionExtractorVisitor = class extends ASTVisitor {
+	/** Source file being parsed */
+	source;
+	/** Module path for building qualified names */
+	modulePath;
+	/** Absolute file path */
+	filePath;
+	/** Accumulated function records, keyed by start line */
+	functions = {};
+	/** Current class name (when inside a class) */
+	currentClassName = null;
+	constructor(source, modulePath, filePath) {
+		super();
+		this.source = source;
+		this.modulePath = modulePath;
+		this.filePath = filePath;
+	}
+	/**
+	* Track class context when entering a class
+	*/
+	onClassEnter(node) {
+		this.currentClassName = node.name?.text ?? "Anonymous";
+	}
+	/**
+	* Restore class context when exiting a class
+	*/
+	onClassExit(_node) {
+		this.currentClassName = null;
+	}
+	/**
+	* Extract function info from function declarations
+	*/
+	onFunctionDeclaration(node) {
+		if (node.body && this.hasBodyStatements(node.body)) {
+			const shortName = node.name?.text ?? "~anonymous";
+			const qualifiedName = `${this.modulePath}/${shortName}`;
+			const range = this.buildRange(node, node.name ?? null);
+			this.addFunction(qualifiedName, shortName, range);
+		}
+		return true;
+	}
+	/**
+	* Extract function info from method declarations
+	*/
+	onMethodDeclaration(node) {
+		if (node.body && this.hasBodyStatements(node.body)) {
+			const methodName = node.name?.text ?? "constructor";
+			const className = this.currentClassName ?? "Unknown";
+			const flags = node.flags;
+			const isStatic = (flags & ASCommonFlags.Static) !== 0;
+			const isGetter = (flags & ASCommonFlags.Get) !== 0;
+			const isSetter = (flags & ASCommonFlags.Set) !== 0;
+			let shortName;
+			if (isStatic) shortName = `${className}.${methodName}`;
+			else if (isGetter) shortName = `${className}#get:${methodName}`;
+			else if (isSetter) shortName = `${className}#set:${methodName}`;
+			else shortName = `${className}#${methodName}`;
+			const qualifiedName = `${this.modulePath}/${shortName}`;
+			const range = this.buildRange(node, node.name ?? null);
+			this.addFunction(qualifiedName, shortName, range);
+		}
+		return true;
+	}
+	/**
+	* Extract function info from variable declarations (arrow functions)
+	*/
+	onVariableDeclaration(node) {
+		if (node.initializer && node.initializer.kind === ASNodeKind.Function) {
+			const funcDecl = node.initializer.declaration;
+			if (funcDecl.body && this.hasBodyStatements(funcDecl.body)) {
+				const shortName = node.name.text;
+				const qualifiedName = `${this.modulePath}/${shortName}`;
+				const range = {
+					filePath: this.filePath,
+					startLine: this.source.lineAt(node.range.start),
+					startColumn: this.source.columnAt(),
+					endLine: this.source.lineAt(node.range.end),
+					endColumn: this.source.columnAt()
+				};
+				this.addFunction(qualifiedName, shortName, range);
+			}
+			if (funcDecl.body) this.visitNode(funcDecl.body);
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Check if a function body has statements (non-empty body)
+	*/
+	hasBodyStatements(body) {
+		if (body.kind === ASNodeKind.Block) return body.statements.length > 0;
+		return true;
+	}
+	/**
+	* Add a function to the functions record, keyed by start line
+	*/
+	addFunction(qualifiedName, shortName, range) {
+		const startLine = range.startLine;
+		if (!this.functions[startLine]) this.functions[startLine] = [];
+		this.functions[startLine].push({
+			qualifiedName,
+			shortName,
+			range
+		});
+	}
+	/**
+	* Build a SourceRange for a node, using name.range.start to skip decorators
+	*/
+	buildRange(node, nameNode) {
+		const startNode = nameNode ?? node;
+		return {
+			filePath: this.filePath,
+			startLine: this.source.lineAt(startNode.range.start),
+			startColumn: this.source.columnAt(),
+			endLine: this.source.lineAt(node.range.end),
+			endColumn: this.source.columnAt()
+		};
+	}
+};
+/**
+* Parse functions from a single AS source file
+*
+* @param absoluteSourceFilePath - Absolute path to AS source file
+* @param relativeSourceFilePath - Relative path to AS source file (derived once in caller and used several places)
+* @returns Record of start line to array of ParsedSourceFunctionInfo (multiple functions can start on same line)
+*/
+async function parseFunctionsFromFile(absoluteSourceFilePath, relativeSourceFilePath) {
+	const sourceCode = await readFile(absoluteSourceFilePath, "utf8");
+	const parsed = parse(relativeSourceFilePath);
+	const modulePath = parsed.dir ? `${parsed.dir}/${parsed.name}` : parsed.name;
+	const asParser = new Parser();
+	asParser.parseFile(sourceCode, relativeSourceFilePath, true);
+	const source = asParser.currentSource;
+	if (!source) return {};
+	const visitor = new FunctionExtractorVisitor(source, modulePath, absoluteSourceFilePath);
+	visitor.visitSource(source);
+	return visitor.functions || {};
+}
+
+//#endregion
+//#region src/coverage-provider/glob-utils.ts
+/**
+* Glob Utilities for Coverage
+*
+* Uses test-exclude (same as Vitest's v8 coverage provider) to glob
+* AssemblyScript files matching coverage.include patterns.
+*/
+/**
+* Glob files matching coverage include/exclude patterns
+*
+* Uses test-exclude for consistent behavior with Vitest's built-in
+* coverage providers.
+*
+* @param include - Include patterns (e.g., ['assembly/**\/*.ts'])
+* @param exclude - Exclude patterns (e.g., ['**\/*.test.ts'])
+* @param projectRoot - Project root directory
+* @returns Array of absolute file paths
+*/
+function globFiles(include, exclude, projectRoot) {
+	if (include.length === 0) return [];
+	return new TestExclude({
+		cwd: projectRoot,
+		include,
+		exclude,
+		excludeNodeModules: true
+	}).globSync(projectRoot).map((file) => ({
+		absolute: resolve$1(projectRoot, file),
+		projectRootRelative: file
+	})) || [];
+}
+
+//#endregion
+//#region src/coverage-provider/hybrid-coverage-provider.ts
+/**
+* Hybrid Coverage Provider
+*
+* This provider handles both AssemblyScript and JavaScript and coverage
+* - Converts AS coverage to Istanbul format
+* - Delegates JS coverage to Vitest's v8 provider
+* - Merges both into a unified coverage report
+*/
+var HybridCoverageProvider = class {
+	name = "hybrid-assemblyscript-v8";
+	v8Provider;
+	accumulatedCoverageData = { hitCountsByFileAndPosition: {} };
+	projectConfig = {};
+	coverageOptions = {};
+	/**
+	* Initialize the provider and get reference to v8 provider
+	*/
+	async initialize(ctx) {
+		this.projectConfig = getProjectSerializedOrGlobalConfig(ctx).config;
+		debug("[HybridCoverageProvider] Initializing Provider");
+		this.v8Provider = await v8CoverageModule.getProvider();
+		if (!this.v8Provider) throw createPoolError("HybridCoverageProvider - initialize failed to get delegated v8 provider", POOL_ERROR_NAMES.HybridCoverageProviderError);
+		await this.v8Provider.initialize(ctx);
+		this.v8Provider.name = "hybrid-assemblyscript-v8 (delegated v8 reporter)";
+		debug("[HybridCoverageProvider] Initialized with delegated v8 provider");
+	}
+	/**
+	* Handle suite completion - delegate based on coverage format marker
+	*/
+	async onAfterSuiteRun(meta) {
+		const start = performance.now();
+		const format = (meta?.coverage)?.__format;
+		let suiteLogLabel = meta.testFiles.length > 0 ? basename(meta.testFiles[0]) : "";
+		if (format === COVERAGE_PAYLOAD_FORMATS.AssemblyScript) {
+			const { coverageData, suiteLogLabel: label } = meta.coverage;
+			suiteLogLabel = label;
+			debug(() => {
+				const fileCount = Object.keys(coverageData.hitCountsByFileAndPosition).length;
+				const positionCount = Object.values(coverageData.hitCountsByFileAndPosition).reduce((sum, positions) => sum + Object.keys(positions).length, 0);
+				return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun - Suite payload: ${positionCount} unique positions over ${fileCount} source files`;
+			});
+			mergeCoverageData(this.accumulatedCoverageData, coverageData);
+			debug(() => {
+				const fileCount = Object.keys(this.accumulatedCoverageData.hitCountsByFileAndPosition).length;
+				const positionCount = Object.values(this.accumulatedCoverageData.hitCountsByFileAndPosition).reduce((sum, positions) => sum + Object.keys(positions).length, 0);
+				return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun - Accumulated coverage: ${positionCount} unique positions over ${fileCount} source files`;
+			});
+		} else {
+			if (!this.v8Provider) throw createPoolError("HybridCoverageProvider - onAfterSuiteRun failed to delegate to v8 provider", POOL_ERROR_NAMES.HybridCoverageProviderError);
+			debug(`[HybridCoverageProvider] ${suiteLogLabel} - Delegating to v8 provider`);
+			await this.v8Provider.onAfterSuiteRun(meta);
+		}
+		debug(() => {
+			const files = meta.testFiles.map((tf) => relative(this.projectConfig.root, tf)).join(",");
+			return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun complete - TIMING ${(performance.now() - start).toFixed(2)} ms | testFiles: "${files}"`;
+		});
+	}
+	/**
+	* Generate unified coverage map (merging JS and AS coverage)
+	*
+	* Flow:
+	* 1. Parse included AS source files to get sourceDebugInfo (source of truth for line numbers)
+	* 1. Build merged CoverageData (all source functions + accumulated hit counts)
+	* 4. Convert merged CoverageData to Istanbul format
+	* 5. Get JS coverage from v8 provider
+	* 6. Merge AS coverage into JS coverage
+	*/
+	async generateCoverage(context) {
+		const start = performance.now();
+		debug("[HybridCoverageProvider] Generating coverage for test run");
+		if (!this.v8Provider) throw createPoolError("HybridCoverageProvider - generateCoverage failed to delegate to v8 provider", POOL_ERROR_NAMES.HybridCoverageProviderError);
+		let asCoverageMap = createCoverageMap();
+		if (this.coverageOptions.globbedAssemblyScriptInclude?.length > 0) {
+			debug(`[HybridCoverageProvider] Building AS coverage map with ${this.coverageOptions.globbedAssemblyScriptInclude.length} source files `);
+			debug(() => {
+				return `[HybridCoverageProvider] Accumulated coverage data has ${Object.values(this.accumulatedCoverageData.hitCountsByFileAndPosition).reduce((sum, positions) => sum + Object.keys(positions)?.length, 0)} unique positions hit across ${Object.keys(this.accumulatedCoverageData.hitCountsByFileAndPosition).length} debug source files`;
+			});
+			const fileProcessingPromises = this.coverageOptions.globbedAssemblyScriptInclude.map(async (include) => {
+				debug(`[HybridCoverageProvider] Parsing AS source for expected coverage: "${include.absolute}" (file key: "${include.projectRootRelative}")`);
+				const functionsByStartLine = await parseFunctionsFromFile(include.absolute, include.projectRootRelative) || {};
+				debug(`[HybridCoverageProvider] Parsed ${Object.keys(functionsByStartLine).length} AS source functions in "${include.projectRootRelative}"`);
+				const fileHitCountsByPosition = this.accumulatedCoverageData.hitCountsByFileAndPosition[include.projectRootRelative] ?? {};
+				debug(`[HybridCoverageProvider] Accumulated AS coverage has ${Object.keys(fileHitCountsByPosition).length} positions for "${include.projectRootRelative}"`);
+				return convertToIstanbulFormat(functionsByStartLine, fileHitCountsByPosition, include.absolute);
+			});
+			const istanbulResults = await Promise.all(fileProcessingPromises);
+			for (const istanbulData of istanbulResults) asCoverageMap.addFileCoverage(istanbulData);
+			debug(`[HybridCoverageProvider] Built AS coverage map with ${Object.keys(asCoverageMap.data).length} files`);
+		} else debug("[HybridCoverageProvider] WARNING: No assemblyScriptInclude patterns yieldled files - Coverage Map will be empty!");
+		const asGenerateEnd = performance.now();
+		debug(`[HybridCoverageProvider] TIMING AS generateCoverage: ${(asGenerateEnd - start).toFixed(2)} ms`);
+		debug("[HybridCoverageProvider] Getting JS coverage from v8 provider");
+		const jsCoverage = await this.v8Provider.generateCoverage(context);
+		debug(`[HybridCoverageProvider] JS coverage has ${Object.keys(jsCoverage.data).length} files`);
+		debug(`[HybridCoverageProvider] TIMING JS generateCoverage: ${(performance.now() - asGenerateEnd).toFixed(2)} ms`);
+		debug("[HybridCoverageProvider] Merging AS coverage into JS coverage");
+		jsCoverage.merge(asCoverageMap);
+		debug(`[HybridCoverageProvider] Final merged coverage has ${Object.keys(jsCoverage.data).length} files`);
+		debug(`[HybridCoverageProvider] TIMING Total generateCoverage: ${(performance.now() - start).toFixed(2)} ms`);
+		return jsCoverage;
+	}
+	/**
+	* Report coverage - delegate to v8 provider
+	*/
+	async reportCoverage(coverageMap, context) {
+		if (!this.v8Provider) throw createPoolError("HybridCoverageProvider - reportCoverage failed to delegate to v8 provider", POOL_ERROR_NAMES.HybridCoverageProviderError);
+		debug(`[HybridCoverageProvider] Reporting coverage (allTestsRun=${context.allTestsRun})`);
+		await this.v8Provider.reportCoverage(coverageMap, context);
+	}
+	/**
+	* Resolve options
+	*/
+	resolveOptions() {
+		if (!this.v8Provider) throw createPoolError("HybridCoverageProvider - resolveOptions failed to delegate to v8 provider", POOL_ERROR_NAMES.HybridCoverageProviderError);
+		debug(`[HybridCoverageProvider] Resolving Coverage Options`);
+		const definedCoverageOptions = this.projectConfig.coverage;
+		const resolvedV8Options = this.v8Provider.resolveOptions();
+		const sanitizedV8Options = {
+			...resolvedV8Options,
+			include: resolvedV8Options.include?.map((i) => i.replace(/\0/g, "")) || void 0,
+			exclude: resolvedV8Options.exclude?.map((i) => i.replace(/\0/g, "")) || void 0
+		};
+		debug(`[HybridCoverageProvider] AS include: ${(definedCoverageOptions.assemblyScriptInclude || []).join(", ") || "(none)"}`);
+		debug(`[HybridCoverageProvider] AS exclude: ${(definedCoverageOptions.assemblyScriptExclude || []).join(", ") || "(none)"}`);
+		debug(`[HybridCoverageProvider] JS include: ${(sanitizedV8Options.include || []).join(", ") || "(none)"}`);
+		debug(`[HybridCoverageProvider] JS exclude: ${(sanitizedV8Options.exclude || []).join(", ") || "(none)"}`);
+		debug(`[HybridCoverageProvider] Globbing AS source files to include for coverage map basis`);
+		const globbedAssemblyScriptInclude = globFiles(definedCoverageOptions.assemblyScriptInclude || [], definedCoverageOptions.assemblyScriptExclude || [], this.projectConfig.root);
+		debug(`[HybridCoverageProvider] Including ${globbedAssemblyScriptInclude.length} AS files in coverage map`);
+		const globbedAssemblyScriptExcludeOnly = globFiles(definedCoverageOptions.assemblyScriptExclude || [], [], this.projectConfig.root);
+		debug(`[HybridCoverageProvider] Excluding ${globbedAssemblyScriptExcludeOnly.length} AS files from coverage map & instrumentation`);
+		const resolvedCoverageOptions = {
+			...resolvedV8Options,
+			provider: "custom",
+			customProviderModule: definedCoverageOptions.customProviderModule,
+			assemblyScriptInclude: definedCoverageOptions.assemblyScriptInclude ?? [],
+			assemblyScriptExclude: definedCoverageOptions.assemblyScriptExclude ?? [],
+			globbedAssemblyScriptInclude,
+			globbedAssemblyScriptProjectRelativeExcludeOnly: globbedAssemblyScriptExcludeOnly.map((gr) => gr.projectRootRelative)
+		};
+		this.coverageOptions = resolvedCoverageOptions;
+		return resolvedCoverageOptions;
+	}
+	async clean(clean = true) {
+		debug("[HybridCoverageProvider] Clean coverage data - clean:", clean);
+		if (clean) {
+			this.accumulatedCoverageData = { hitCountsByFileAndPosition: {} };
+			debug("[HybridCoverageProvider] Cleaned all internal coverage data");
+		}
+		if (this.v8Provider) {
+			await this.v8Provider.clean(clean);
+			debug(`[HybridCoverageProvider] V8 provider finished clean(${clean})`);
+		}
+	}
+};
+
+//#endregion
+//#region src/coverage-provider/index.ts
+/**
+* Hybrid Coverage Provider
+*
+* This provider handles both AssemblyScript and JavaScript and coverage
+* - Converts AS coverage to Istanbul format
+* - Delegates JS coverage to Vitest's v8 provider
+* - Merges both into a unified coverage report
+*/
+const hybridProviderModule = {
+	getProvider: () => new HybridCoverageProvider(),
+	startCoverage: async (runtimeOptions) => {
+		if (v8CoverageModule.startCoverage) return await v8CoverageModule.startCoverage(runtimeOptions);
+		else throw createPoolError("HybridCoverageProvider - v8 coverage module does not provide `startCoverage`", POOL_ERROR_NAMES.HybridCoverageProviderError);
+	},
+	takeCoverage: async (runtimeOptions) => {
+		if (v8CoverageModule.takeCoverage) return await v8CoverageModule.takeCoverage(runtimeOptions);
+		else throw createPoolError("HybridCoverageProvider - v8 coverage module does not provide `takeCoverage`", POOL_ERROR_NAMES.HybridCoverageProviderError);
+	},
+	stopCoverage: async (runtimeOptions) => {
+		if (v8CoverageModule.stopCoverage) return await v8CoverageModule.stopCoverage(runtimeOptions);
+		else throw createPoolError("HybridCoverageProvider - v8 coverage module does not provide `stopCoverage`", POOL_ERROR_NAMES.HybridCoverageProviderError);
+	}
+};
+var coverage_provider_default = hybridProviderModule;
+
+//#endregion
+export { coverage_provider_default as default };
+//# sourceMappingURL=index.mjs.map