vitest-pool-assemblyscript 0.2.0

package/dist/compiler-CN6BRK_N.mjs

@@ -0,0 +1,295 @@
+import { POOL_ERROR_NAMES } from "./constants-CA50WBdr.mjs";
+import { createPoolError, debug, throwPoolErrorIfAborted } from "./debug-IeEHsxy0.mjs";
+import { createRequire } from "node:module";
+import { basename, dirname, resolve } from "node:path";
+import { access } from "node:fs/promises";
+import { main } from "assemblyscript/asc";
+import { fileURLToPath } from "node:url";
+
+//#region src/native-instrumentation/addon-interface.ts
+/**
+* Native addon interface for extracting debug information from WebAssembly binaries
+*
+* This module wraps Binaryen's C++ API to provide expression-level debug locations
+* and basic block information that the JavaScript API doesn't expose.
+*
+* The native addon outputs raw data (0-based columns, relative paths) which this
+* wrapper transforms into the final BinaryDebugInfo format (1-based columns,
+* absolute paths, grouped by file and position).
+*/
+const DEBUG_NATIVE_ADDON = false;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootFromDist = resolve(__dirname, "..");
+const rootFromSrc = resolve(__dirname, "../..");
+const nodeGypBuild = createRequire(import.meta.url)("node-gyp-build");
+let addon;
+try {
+	addon = nodeGypBuild(rootFromDist);
+} catch {
+	try {
+		addon = nodeGypBuild(rootFromSrc);
+	} catch (err) {
+		throw createPoolError(`Native addon not found. Searched from ${rootFromDist} and ${rootFromSrc}. Ensure prebuilds are available or run 'npm run build:native' to compile from source. Original error: ${err instanceof Error ? err.message : String(err)}`, POOL_ERROR_NAMES.WASMInstrumentationError);
+	}
+}
+/**
+* Convert a raw location (0-indexed columns, path indexes) to 
+* processed location (1-indexed columns, path strings)
+*/
+function convertLocation(rawLocation, debugSourceFiles) {
+	const filePath = debugSourceFiles[rawLocation.fileIndex];
+	if (!filePath) throw createPoolError(`No debug source file with index: ${rawLocation.fileIndex}}`, POOL_ERROR_NAMES.WASMInstrumentationError);
+	return {
+		filePath,
+		line: rawLocation.line,
+		column: rawLocation.column + 1
+	};
+}
+/**
+* Convert a raw expression to processed format
+*/
+function convertExpression(rawExpr, debugSourceFiles) {
+	const converted = {
+		type: rawExpr.type,
+		isBranch: rawExpr.isBranch
+	};
+	if (rawExpr.branchPaths !== void 0) converted.branchPaths = rawExpr.branchPaths;
+	if (rawExpr.location) {
+		const convertedLocation = convertLocation(rawExpr.location, debugSourceFiles);
+		if (convertedLocation) converted.location = convertedLocation;
+	}
+	return converted;
+}
+/**
+* Generate a position key to identify the SourceLocation uniquely
+* within a file. Does NOT include the file identifier.
+*/
+function getPositionKey(location) {
+	return `${location.line}:${location.column}`;
+}
+/**
+* Convert a raw function to processed format and compute position key
+* Returns undefined if function has no valid representative location
+*/
+function convertFunction(rawFunc, debugSourceFiles) {
+	const representativeLocation = convertLocation(rawFunc.representativeLocation, debugSourceFiles);
+	const expressions = [];
+	if (rawFunc.expressions) for (const expr of rawFunc.expressions) expressions.push(convertExpression(expr, debugSourceFiles));
+	return {
+		func: {
+			wasmIndex: rawFunc.wasmIndex,
+			name: rawFunc.name,
+			representativeLocation,
+			coverageMemoryIndex: rawFunc.coverageMemoryIndex,
+			expressions,
+			basicBlocks: rawFunc.basicBlocks
+		},
+		filePath: representativeLocation.filePath,
+		positionKey: getPositionKey(representativeLocation)
+	};
+}
+/**
+* Transform raw native addon output to processed BinaryDebugInfo
+*/
+function transformDebugInfo(raw, logPrefix) {
+	const functionsByFileAndPosition = {};
+	debug(`${logPrefix} - Converting ${raw.functions.length} functions`);
+	let positionCollisionCount = 0;
+	let skippedCount = 0;
+	let instrumentedFunctionCount = 0;
+	for (const rawFunc of raw.functions) {
+		const result = convertFunction(rawFunc, raw.debugSourceFiles);
+		if (!result) {
+			debug(`${logPrefix} - WARNING: Skipped function (bad conversion): "${rawFunc.name}"`);
+			skippedCount++;
+			continue;
+		}
+		const { func, filePath, positionKey } = result;
+		if (functionsByFileAndPosition[filePath]?.[positionKey]) {
+			const existing = functionsByFileAndPosition[filePath][positionKey];
+			positionCollisionCount++;
+			throw createPoolError(`ERROR - Function Debug Position Collision at ${filePath}:${positionKey}: "${existing.name}" will be replaced by "${func.name}"`, POOL_ERROR_NAMES.WASMInstrumentationError);
+		}
+		instrumentedFunctionCount++;
+		if (!functionsByFileAndPosition[filePath]) functionsByFileAndPosition[filePath] = {};
+		functionsByFileAndPosition[filePath][positionKey] = func;
+	}
+	debug(`${logPrefix} - BinaryDebugInfo transform complete: ${instrumentedFunctionCount} instrumented functions (${positionCollisionCount} position collisions, ${skippedCount} skipped)`);
+	return {
+		debugSourceFiles: raw.debugSourceFiles,
+		functionsByFileAndPosition,
+		instrumentedFunctionCount
+	};
+}
+/**
+* Instrument a WASM binary for coverage collection and regenerate source map
+*
+* This function:
+* 1. Adds __coverage_memory import (multi-memory for coverage counters)
+* 2. Injects coverage counter increments at each function entry
+* 3. Regenerates source map with correct offsets after instrumentation
+* 4. Extracts debug info with coverageMemoryIndex assigned
+*
+* @param wasmBuffer - Buffer containing the clean WASM binary
+* @param sourceMapBuffer - Buffer containing the source map JSON
+* @returns Instrumented binary, regenerated source map, and debug info
+*
+* @throws {TypeError} If wasmBuffer or sourceMapBuffer are not Buffers
+* @throws {Error} If WASM binary or source map is invalid
+*/
+function instrumentForCoverage(wasmBuffer, sourceMapBuffer, instrumentationOptions, logModule, logLabel) {
+	if (!Buffer.isBuffer(wasmBuffer)) throw createPoolError("instrumentForCoverage - wasmBuffer must be a Buffer", POOL_ERROR_NAMES.WASMInstrumentationError);
+	if (!Buffer.isBuffer(sourceMapBuffer)) throw createPoolError("instrumentForCoverage - sourceMapBuffer must be a Buffer", POOL_ERROR_NAMES.WASMInstrumentationError);
+	const interfaceLogPrefix = `[${logModule} Inst] ${logLabel}`;
+	const nativeLogPrefix = `[${logModule} InstNative] ${logLabel}`;
+	debug(`${interfaceLogPrefix} - Calling native instrumentForCoverage`);
+	const startTime = performance.now();
+	const options = {
+		coverageMemoryPagesMin: instrumentationOptions.coverageMemoryPagesMin,
+		coverageMemoryPagesMax: instrumentationOptions.coverageMemoryPagesMax,
+		excludedFiles: instrumentationOptions.relativeExcludedFiles,
+		excludedLibraryFilePrefix: instrumentationOptions.excludedLibraryFilePrefix,
+		debug: DEBUG_NATIVE_ADDON,
+		logPrefix: nativeLogPrefix
+	};
+	const nativeResult = addon.instrumentForCoverage(wasmBuffer, sourceMapBuffer, options);
+	const addonTime = performance.now();
+	debug(`${interfaceLogPrefix} - TIMING Native addon: ${(addonTime - startTime).toFixed(2)} ms`);
+	if (nativeResult.errors?.length) throw createPoolError(`Errors encountered duriing native instrumentation: ${nativeResult.errors.join("\n")}`, POOL_ERROR_NAMES.WASMInstrumentationError);
+	const debugInfo = transformDebugInfo(nativeResult.debugInfo, interfaceLogPrefix);
+	debug(`${interfaceLogPrefix} - TIMING DebugInfo Transform: ${(performance.now() - addonTime).toFixed(2)} ms`);
+	debug(`${interfaceLogPrefix} - Binary size: ${nativeResult.instrumentedWasm.length} bytes | Source map size: ${nativeResult.sourceMap.length * 2} bytes`);
+	return {
+		instrumentedWasm: nativeResult.instrumentedWasm,
+		sourceMap: nativeResult.sourceMap,
+		debugInfo
+	};
+}
+
+//#endregion
+//#region src/compiler/index.ts
+/**
+* AssemblyScript Compiler
+*
+* Handles compilation of AssemblyScript source code to WASM binaries.
+* Manages compiler options, transforms, and in-memory compilation.
+*/
+const STRIP_INLINE_TRANSFORM = resolve(import.meta.dirname, "./compiler/transforms/strip-inline.mjs");
+setImmediate(async () => {
+	try {
+		await access(STRIP_INLINE_TRANSFORM);
+	} catch {
+		throw createPoolError(`AS Compiler strip inline transform file not found at "${STRIP_INLINE_TRANSFORM}"`, POOL_ERROR_NAMES.CompilationError);
+	}
+});
+/**
+* Compile AssemblyScript source code to WASM binary
+*
+* Features:
+* - In-memory compilation (binary captured via writeFile callback)
+* - Filesystem reading enabled (for import resolution)
+* - Uses stub runtime and imported memory pattern
+* - Exports _start function for explicit initialization control
+* - Always returns clean binary
+* - Conditionally returns instrumented binary when coverage enabled
+*
+* @param filename - Full path to the source file (used as entry point)
+* @param options - Compilation options (coverage mode, etc.)
+* @returns Compilation result with clean binary and optional instrumented binary
+* @throws Error if compilation fails
+*/
+async function compileAssemblyScript(filename, options, logModule, logLabel, signal) {
+	throwPoolErrorIfAborted(signal);
+	const compileStart = performance.now();
+	const logPrefix = `[${logModule} ASC] ${logLabel}`;
+	const { shouldInstrument, instrumentationOptions, extraFlags } = options;
+	if (shouldInstrument && !instrumentationOptions) throw createPoolError("Instrumentation options are required for coverage instrumentation", POOL_ERROR_NAMES.CompilationError);
+	const stdoutLines = [];
+	const stderrLines = [];
+	let binary;
+	let sourceMap;
+	const entryFile = filename;
+	const outputFile = "output.wasm";
+	debug(`${logPrefix} - Compiling: "${filename}"`);
+	const stdout = { write: (text) => {
+		stdoutLines.push(text);
+		return true;
+	} };
+	const stderr = { write: (text) => {
+		stderrLines.push(text);
+		return true;
+	} };
+	const compilerFlags = [
+		entryFile,
+		"--optimizeLevel",
+		"0",
+		"--shrinkLevel",
+		"0",
+		"--runtime",
+		"stub",
+		...extraFlags || [],
+		"--outFile",
+		outputFile,
+		"--importMemory",
+		"--debug",
+		"--sourceMap",
+		"--exportStart",
+		"_start",
+		"--exportTable"
+	];
+	if (options.stripInline === true) {
+		compilerFlags.push("--transform", STRIP_INLINE_TRANSFORM);
+		debug(`${logPrefix} - Added Transform - Stripping @inline decorators`);
+	}
+	const ascStart = performance.now();
+	const result = await main(compilerFlags, {
+		stdout,
+		stderr,
+		writeFile: (name, contents, _baseDir) => {
+			throwPoolErrorIfAborted(signal);
+			if (name.endsWith(".wasm") && contents instanceof Uint8Array) {
+				binary = contents;
+				debug(`${logPrefix} - Captured binary in memory: "${name}"`);
+			} else if (name.endsWith(".wasm.map") && typeof contents === "string") {
+				debug(`${logPrefix} - Captured source map in memory: "${name}"`);
+				sourceMap = contents;
+			} else debug(`${logPrefix} - WARNING - Captured Unexpected File: "${name}" at baseDir: "${_baseDir}"`);
+		}
+	});
+	debug(`${logPrefix} - TIMING asc.main: ${(performance.now() - ascStart).toFixed(2)} ms`);
+	if (result.error) {
+		const errorMessage = stderrLines.length > 0 ? `${result.error.message}\n\n${stderrLines.join("")}` : result.error.message;
+		throw createPoolError(errorMessage, POOL_ERROR_NAMES.CompilationError, errorMessage);
+	}
+	if (!binary) throw createPoolError(stderrLines.length > 0 ? `No WASM binary was generated\n\nAS Compiler output:\n${stderrLines.join("")}` : "No WASM binary was generated", POOL_ERROR_NAMES.CompilationError);
+	if (!sourceMap) throw createPoolError("Source map not captured from AssemblyScript Compiler", POOL_ERROR_NAMES.CompilationError);
+	const cleanBinary = binary;
+	const wasmSourceMap = sourceMap;
+	debug(`${logPrefix} - Compilation successful, clean binary size: ${cleanBinary.length} bytes`);
+	debug(`${logPrefix} - Source map generated, size: ${wasmSourceMap.length * 2} bytes`);
+	if (options.shouldInstrument) {
+		throwPoolErrorIfAborted(signal);
+		const instrumentStart = performance.now();
+		const instrumentResult = instrumentForCoverage(Buffer.from(cleanBinary), Buffer.from(wasmSourceMap), options.instrumentationOptions, logModule, logLabel);
+		const instCount = instrumentResult.debugInfo.instrumentedFunctionCount;
+		const instrumentEnd = performance.now();
+		debug(`${logPrefix} - TIMING Instrumented ${instCount} functions: ${(performance.now() - instrumentStart).toFixed(2)} ms`);
+		return {
+			binary: instrumentResult.instrumentedWasm,
+			sourceMap: instrumentResult.sourceMap,
+			debugInfo: instrumentResult.debugInfo,
+			isInstrumented: true,
+			compileTiming: instrumentEnd - compileStart
+		};
+	}
+	return {
+		binary: cleanBinary,
+		sourceMap: wasmSourceMap,
+		isInstrumented: false,
+		compileTiming: performance.now() - compileStart
+	};
+}
+
+//#endregion
+export { compileAssemblyScript };
+//# sourceMappingURL=compiler-CN6BRK_N.mjs.map

package/dist/compiler-CN6BRK_N.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-CN6BRK_N.mjs","names":["ascMain"],"sources":["../src/native-instrumentation/addon-interface.ts","../src/compiler/index.ts"],"sourcesContent":["/**\n * Native addon interface for extracting debug information from WebAssembly binaries\n *\n * This module wraps Binaryen's C++ API to provide expression-level debug locations\n * and basic block information that the JavaScript API doesn't expose.\n *\n * The native addon outputs raw data (0-based columns, relative paths) which this\n * wrapper transforms into the final BinaryDebugInfo format (1-based columns,\n * absolute paths, grouped by file and position).\n */\n\nimport { createRequire } from 'node:module';\nimport { resolve, dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { debug } from '../util/debug.js';\nimport {\n  NativeAddon,\n  NativeInstrumentationResult,\n  NativeDebugInfoOutput,\n  NativeFunctionDebugInfo,\n  NativeExpressionDebugInfo,\n  NativeSourceLocation,\n  BinaryDebugInfo,\n  FunctionDebugInfo,\n  SourceLocation,\n  ExpressionDebugInfo,\n  InstrumentationResult,\n  NativeInstrumentationOptions,\n  InstrumentationOptions,\n} from '../types/types.js';\nimport { POOL_ERROR_NAMES } from '../types/constants.js';\nimport { createPoolError } from '../util/pool-errors.js';\n\nconst DEBUG_NATIVE_ADDON = false;\n\n// Load the native addon via node-gyp-build\n// node-gyp-build checks: prebuilds/ first, then build/Release/\n// It searches from the given directory for a package.json to find the package root.\n// We run from dist/ (published) or src/ (dev/tests), so we try both root paths.\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\nconst rootFromDist = resolve(__dirname, '..');\nconst rootFromSrc = resolve(__dirname, '../..');\n\nconst require = createRequire(import.meta.url);\nconst nodeGypBuild: (dir: string) => NativeAddon = require('node-gyp-build');\n\nlet addon: NativeAddon;\ntry {\n  addon = nodeGypBuild(rootFromDist);\n} catch {\n  try {\n    addon = nodeGypBuild(rootFromSrc);\n  } catch (err) {\n    throw createPoolError(\n      `Native addon not found. Searched from ${rootFromDist} and ${rootFromSrc}. ` +\n      `Ensure prebuilds are available or run 'npm run build:native' to compile from source. ` +\n      `Original error: ${err instanceof Error ? err.message : String(err)}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n}\n\n/**\n * Convert a raw location (0-indexed columns, path indexes) to \n * processed location (1-indexed columns, path strings)\n */\nfunction convertLocation(\n  rawLocation: NativeSourceLocation,\n  debugSourceFiles: string[]\n): SourceLocation {\n  const filePath = debugSourceFiles[rawLocation.fileIndex];\n\n  if (!filePath) {\n    throw createPoolError(\n      `No debug source file with index: ${rawLocation.fileIndex}}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n  \n  return {\n    filePath: filePath!,\n    line: rawLocation.line,\n    column: rawLocation.column + 1,  // convert from 0-indexed to 1-indexed\n  };\n}\n\n/**\n * Convert a raw expression to processed format\n */\nfunction convertExpression(\n  rawExpr: NativeExpressionDebugInfo,\n  debugSourceFiles: string[]\n): ExpressionDebugInfo {\n  const converted: ExpressionDebugInfo = {\n    type: rawExpr.type,\n    isBranch: rawExpr.isBranch,\n  };\n\n  if (rawExpr.branchPaths !== undefined) {\n    converted.branchPaths = rawExpr.branchPaths;\n  }\n\n  if (rawExpr.location) {\n    const convertedLocation = convertLocation(rawExpr.location, debugSourceFiles);\n    if (convertedLocation) {\n      converted.location = convertedLocation;\n    }\n  }\n\n  return converted;\n}\n\n/**\n * Generate a position key to identify the SourceLocation uniquely\n * within a file. Does NOT include the file identifier.\n */\nfunction getPositionKey(location: SourceLocation) {\n  return `${location.line}:${location.column}`;\n}\n\n/**\n * Convert a raw function to processed format and compute position key\n * Returns undefined if function has no valid representative location\n */\nfunction convertFunction(\n  rawFunc: NativeFunctionDebugInfo,\n  debugSourceFiles: string[]\n): { func: FunctionDebugInfo; filePath: string; positionKey: string } | undefined {\n  const representativeLocation = convertLocation(rawFunc.representativeLocation, debugSourceFiles);\n\n  // Convert expressions\n  const expressions: ExpressionDebugInfo[] = [];\n  if (rawFunc.expressions) {\n    for (const expr of rawFunc.expressions) {\n      expressions.push(convertExpression(expr, debugSourceFiles));\n    }\n  }\n\n  const converted: FunctionDebugInfo = {\n    wasmIndex: rawFunc.wasmIndex,\n    name: rawFunc.name,\n    representativeLocation,\n    coverageMemoryIndex: rawFunc.coverageMemoryIndex,\n    expressions,\n    basicBlocks: rawFunc.basicBlocks,\n  };\n\n  const filePath = representativeLocation.filePath;\n  const positionKey = getPositionKey(representativeLocation);\n\n  return { func: converted, filePath, positionKey };\n}\n\n/**\n * Transform raw native addon output to processed BinaryDebugInfo\n */\nfunction transformDebugInfo(\n  raw: NativeDebugInfoOutput,\n  logPrefix: string,\n): BinaryDebugInfo {\n  const functionsByFileAndPosition: Record<string, Record<string, FunctionDebugInfo>> = {};\n\n  debug(`${logPrefix} - Converting ${raw.functions.length} functions`);\n\n  let positionCollisionCount = 0;\n  let skippedCount = 0;\n  let instrumentedFunctionCount = 0;\n  \n  for (const rawFunc of raw.functions) {\n    const result = convertFunction(rawFunc, raw.debugSourceFiles);\n    if (!result) {\n      debug(`${logPrefix} - WARNING: Skipped function (bad conversion): \"${rawFunc.name}\"`);\n      skippedCount++;\n      continue;\n    }\n\n    const { func, filePath, positionKey } = result;\n\n    // Check for position collisions\n    if (functionsByFileAndPosition[filePath]?.[positionKey]) {\n      const existing = functionsByFileAndPosition[filePath][positionKey];\n      positionCollisionCount++;\n      throw createPoolError(\n        `ERROR - Function Debug Position Collision at ${filePath}:${positionKey}: \"${existing.name}\" will be replaced by \"${func.name}\"`,\n        POOL_ERROR_NAMES.WASMInstrumentationError\n      );\n    }\n\n    instrumentedFunctionCount++;\n\n    // Group by file and position\n    if (!functionsByFileAndPosition[filePath]) {\n      functionsByFileAndPosition[filePath] = {};\n    }\n\n    functionsByFileAndPosition[filePath][positionKey] = func;\n  }\n\n  debug(\n    `${logPrefix} - BinaryDebugInfo transform complete: ${instrumentedFunctionCount} instrumented functions`\n    +` (${positionCollisionCount} position collisions, ${skippedCount} skipped)`\n  );\n\n  return {\n    debugSourceFiles: raw.debugSourceFiles,\n    functionsByFileAndPosition,\n    instrumentedFunctionCount,\n  };\n}\n\n/**\n * Instrument a WASM binary for coverage collection and regenerate source map\n *\n * This function:\n * 1. Adds __coverage_memory import (multi-memory for coverage counters)\n * 2. Injects coverage counter increments at each function entry\n * 3. Regenerates source map with correct offsets after instrumentation\n * 4. Extracts debug info with coverageMemoryIndex assigned\n *\n * @param wasmBuffer - Buffer containing the clean WASM binary\n * @param sourceMapBuffer - Buffer containing the source map JSON\n * @returns Instrumented binary, regenerated source map, and debug info\n *\n * @throws {TypeError} If wasmBuffer or sourceMapBuffer are not Buffers\n * @throws {Error} If WASM binary or source map is invalid\n */\nexport function instrumentForCoverage(\n  wasmBuffer: Buffer,\n  sourceMapBuffer: Buffer,\n  instrumentationOptions: InstrumentationOptions,\n  logModule: string,\n  logLabel: string,\n): InstrumentationResult {\n  if (!Buffer.isBuffer(wasmBuffer)) {\n    throw createPoolError(\n      'instrumentForCoverage - wasmBuffer must be a Buffer',\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n  if (!Buffer.isBuffer(sourceMapBuffer)) {\n    throw createPoolError(\n      'instrumentForCoverage - sourceMapBuffer must be a Buffer',\n      POOL_ERROR_NAMES.WASMInstrumentationError\n    );\n  }\n\n  const interfaceLogPrefix = `[${logModule} Inst] ${logLabel}`;\n  const nativeLogPrefix = `[${logModule} InstNative] ${logLabel}`;\n\n  debug(`${interfaceLogPrefix} - Calling native instrumentForCoverage`);\n  const startTime = performance.now();\n\n  const options: NativeInstrumentationOptions = {\n    coverageMemoryPagesMin: instrumentationOptions.coverageMemoryPagesMin,\n    coverageMemoryPagesMax: instrumentationOptions.coverageMemoryPagesMax,\n    excludedFiles: instrumentationOptions.relativeExcludedFiles,\n    excludedLibraryFilePrefix: instrumentationOptions.excludedLibraryFilePrefix,\n    debug: DEBUG_NATIVE_ADDON,\n    logPrefix: nativeLogPrefix\n  };\n  const nativeResult: NativeInstrumentationResult = addon.instrumentForCoverage(wasmBuffer, sourceMapBuffer, options);\n  const addonTime = performance.now();\n  debug(`${interfaceLogPrefix} - TIMING Native addon: ${(addonTime - startTime).toFixed(2)} ms`);\n\n  if (nativeResult.errors?.length) {\n    throw createPoolError(\n      `Errors encountered duriing native instrumentation: ${nativeResult.errors.join('\\n')}`,\n      POOL_ERROR_NAMES.WASMInstrumentationError,\n    );\n  } \n\n  const debugInfo = transformDebugInfo(nativeResult.debugInfo, interfaceLogPrefix);\n  \n  const transformTime = performance.now();\n  debug(`${interfaceLogPrefix} - TIMING DebugInfo Transform: ${(transformTime - addonTime).toFixed(2)} ms`);\n  debug(`${interfaceLogPrefix} - Binary size: ${nativeResult.instrumentedWasm.length} bytes | Source map size: ${nativeResult.sourceMap.length * 2} bytes`);\n\n  return {\n    instrumentedWasm: nativeResult.instrumentedWasm,\n    sourceMap: nativeResult.sourceMap,\n    debugInfo,\n  };\n}\n","/**\n * AssemblyScript Compiler\n *\n * Handles compilation of AssemblyScript source code to WASM binaries.\n * Manages compiler options, transforms, and in-memory compilation.\n */\n\nimport { main as ascMain } from 'assemblyscript/asc';\nimport { basename, resolve } from 'node:path';\nimport { access } from 'node:fs/promises';\nimport { writeFile, mkdir } from 'node:fs/promises';\n\nimport { AssemblyScriptCompilerResult, AssemblyScriptCompilerOptions } from '../types/types.js';\nimport { POOL_ERROR_NAMES } from '../types/constants.js';\nimport { debug } from '../util/debug.js';\nimport { instrumentForCoverage } from '../native-instrumentation/addon-interface.js';\nimport { createPoolError, throwPoolErrorIfAborted } from '../util/pool-errors.js';\n\nconst DEBUG_WRITE_FILES = false;\n\n// path assumes that we're running from dist/\nconst STRIP_INLINE_TRANSFORM = resolve(import.meta.dirname, './compiler/transforms/strip-inline.mjs');\n\nsetImmediate(async () => {\n  try {\n    await access(STRIP_INLINE_TRANSFORM);\n  } catch {\n    throw createPoolError(\n      `AS Compiler strip inline transform file not found at \"${STRIP_INLINE_TRANSFORM}\"`,\n      POOL_ERROR_NAMES.CompilationError\n    );\n  }\n});\n\n/**\n * Compile AssemblyScript source code to WASM binary\n *\n * Features:\n * - In-memory compilation (binary captured via writeFile callback)\n * - Filesystem reading enabled (for import resolution)\n * - Uses stub runtime and imported memory pattern\n * - Exports _start function for explicit initialization control\n * - Always returns clean binary\n * - Conditionally returns instrumented binary when coverage enabled\n *\n * @param filename - Full path to the source file (used as entry point)\n * @param options - Compilation options (coverage mode, etc.)\n * @returns Compilation result with clean binary and optional instrumented binary\n * @throws Error if compilation fails\n */\nexport async function compileAssemblyScript(\n  filename: string,\n  options: AssemblyScriptCompilerOptions,\n  logModule: string,\n  logLabel: string,\n  signal?: AbortSignal\n): Promise<AssemblyScriptCompilerResult> {\n  throwPoolErrorIfAborted(signal);\n\n  const compileStart = performance.now();\n  const logPrefix = `[${logModule} ASC] ${logLabel}`;\n\n  const { shouldInstrument, instrumentationOptions, extraFlags } = options;\n\n  if (shouldInstrument && !instrumentationOptions) {\n    throw createPoolError(\n      'Instrumentation options are required for coverage instrumentation',\n      POOL_ERROR_NAMES.CompilationError\n    );\n  }\n\n  const stdoutLines: string[] = [];\n  const stderrLines: string[] = [];\n  let binary: Uint8Array | undefined;\n  let sourceMap: string | undefined;\n\n  // Use full path as entry file so AS compiler can resolve relative imports\n  const entryFile = filename;\n  // Use simple output name to avoid AS compiler prepending it to source map paths\n  const outputFile = 'output.wasm';\n\n  debug(`${logPrefix} - Compiling: \"${filename}\"`);\n\n  // Capture stdout/stderr (for potential error reporting)\n  const stdout = {\n    write: (text: string) => {\n      stdoutLines.push(text);\n      return true;\n    }\n  };\n\n  const stderr = {\n    write: (text: string) => {\n      stderrLines.push(text);\n      return true;\n    }\n  };\n\n  // Build compiler flags\n  const compilerFlags = [\n    entryFile,\n\n    // overrideable, though not recommended\n    '--optimizeLevel', '0',           // No optimization for easier debugging\n    '--shrinkLevel', '0',             // No shrink\n    '--runtime', 'stub',              // stub runtime (no GC)\n\n    ...(extraFlags || []),\n\n    // non-overrideable\n    '--outFile', outputFile,\n    '--importMemory',                 // Import memory from JS (enables imports during WASM start)\n    '--debug',                        // Include debug info\n    '--sourceMap',                    // Generate source maps for error reporting\n    '--exportStart', '_start',        // Export start function for explicit initialization control\n    '--exportTable'                   // Export function table for direct test execution\n  ];\n\n  // Add transform to strip @inline decorators if requested\n  // This improves coverage accuracy by preventing functions from being inlined,\n  // and enables correct source-mapped error reporting for errors originating\n  // inside inlined functions.\n  if (options.stripInline === true) {\n    compilerFlags.push(\n      '--transform', STRIP_INLINE_TRANSFORM\n    );\n    debug(`${logPrefix} - Added Transform - Stripping @inline decorators`);\n  }\n\n  // Compile with AssemblyScript compiler\n  const ascStart = performance.now();\n  const result = await ascMain(compilerFlags, {\n    stdout,\n    stderr,\n    // Let AS read from filesystem for import resolution\n    // WASM binary and source map are captured in memory via writeFile callback\n    writeFile: (name: string, contents: string | Uint8Array, _baseDir: string) => {\n      throwPoolErrorIfAborted(signal);\n\n      if (name.endsWith('.wasm') && contents instanceof Uint8Array) {\n        binary = contents;\n        debug(`${logPrefix} - Captured binary in memory: \"${name}\"`);\n      } else if (name.endsWith('.wasm.map') && typeof contents === 'string') {\n        debug(`${logPrefix} - Captured source map in memory: \"${name}\"`);\n        sourceMap = contents;\n      } else {\n        debug(`${logPrefix} - WARNING - Captured Unexpected File: \"${name}\" at baseDir: \"${_baseDir}\"`);\n      }\n    },\n  });\n\n  debug(`${logPrefix} - TIMING asc.main: ${(performance.now() - ascStart).toFixed(2)} ms`);\n\n  if (result.error) {\n    const errorMessage = stderrLines.length > 0\n      ? `${result.error.message}\\n\\n${stderrLines.join('')}`\n      : result.error.message;\n\n    throw createPoolError(errorMessage, POOL_ERROR_NAMES.CompilationError, errorMessage);\n  }\n\n  if (!binary) {\n    const errorMessage = stderrLines.length > 0\n      ? `No WASM binary was generated\\n\\nAS Compiler output:\\n${stderrLines.join('')}`\n      : 'No WASM binary was generated';\n\n    throw createPoolError(errorMessage, POOL_ERROR_NAMES.CompilationError);\n  }\n\n  if (!sourceMap) {\n    throw createPoolError('Source map not captured from AssemblyScript Compiler', POOL_ERROR_NAMES.CompilationError);\n  }\n\n  const cleanBinary: Uint8Array = binary;\n  const wasmSourceMap: string = sourceMap;\n\n  debug(`${logPrefix} - Compilation successful, clean binary size: ${cleanBinary.length} bytes`);\n  debug(`${logPrefix} - Source map generated, size: ${wasmSourceMap.length * 2} bytes`);\n  \n  if (DEBUG_WRITE_FILES) {\n    // Write source map to project maps directory for debugging\n    const dir = './debug';\n    const sourceMapFileName = `${basename(filename, '.ts')}.as.ts.map`;\n    const sourceMapPath = `${dir}/${sourceMapFileName}`;\n\n    // Create directory if it doesn't exist\n    try {\n      await mkdir(dir, { recursive: true });\n    } catch {\n      // Directory already exists or creation failed, continue\n    }\n\n    // Format as well-formed JSON\n    const formattedSourceMap = JSON.stringify(JSON.parse(wasmSourceMap), null, 2);\n\n    writeFile(sourceMapPath, formattedSourceMap, { encoding: 'utf8' });\n    debug(`${logPrefix} - Wrote source map to: \"${sourceMapPath}\"`);\n\n    // Also write WASM binary for inspection\n    const wasmPath = sourceMapPath.replace('.map', '.wasm');\n    writeFile(wasmPath, cleanBinary);\n    debug(`${logPrefix} - Wrote WASM binary to: \"${wasmPath}\"`);\n  }\n\n  // Instrument binary for coverage if requested\n  if (options.shouldInstrument) {\n    throwPoolErrorIfAborted(signal);\n\n    const instrumentStart = performance.now();\n    const wasmBuffer = Buffer.from(cleanBinary);\n    const sourceMapBuffer = Buffer.from(wasmSourceMap);\n\n    const instrumentResult = instrumentForCoverage(wasmBuffer, sourceMapBuffer, options.instrumentationOptions!, logModule, logLabel);\n    const instCount = instrumentResult.debugInfo.instrumentedFunctionCount;\n\n    const instrumentEnd = performance.now();\n    debug(`${logPrefix} - TIMING Instrumented ${instCount} functions: ${(performance.now() - instrumentStart).toFixed(2)} ms`);\n\n    return {\n      binary: instrumentResult.instrumentedWasm,\n      sourceMap: instrumentResult.sourceMap,\n      debugInfo: instrumentResult.debugInfo,\n      isInstrumented: true,\n      compileTiming: instrumentEnd - compileStart,\n    };\n  }\n\n  // No instrumentation requested\n  return {\n    binary: cleanBinary,\n    sourceMap: wasmSourceMap,\n    isInstrumented: false,\n    compileTiming: performance.now() - compileStart,\n  };\n}\n"],"mappings":"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"}

package/dist/config/index-v3.d.mts

@@ -0,0 +1,111 @@
+import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-8KKo9Hbf.mjs";
+import "../custom-provider-options-CF5C1kXb.mjs";
+import { ConfigEnv, UserWorkspaceConfig, ViteUserConfig } from "vitest/config";
+
+//#region src/config/config-helpers-v3.d.ts
+/**
+* AssemblyScript pool configuration with proper typing for poolOptions
+*
+* Use this type with `defineAssemblyScriptConfig` for root-level configs,
+* or `defineAssemblyScriptProject` for project-level configs.
+* 
+* Vitest v3's ProjectConfig narrows poolOptions as an inline object type,
+* which cannot be augmented via TypeScript module augmentation. Config helpers
+* use type intersection to add poolOptions.assemblyScript typing.
+*
+* Note: Coverage is NOT included here because it's global-only config in Vitest.
+* Coverage typing comes from the CustomProviderOptions augmentation above.
+*/
+type AssemblyScriptUserConfig<T extends ViteUserConfig> = T & {
+  test?: {
+    poolOptions?: {
+      assemblyScript?: AssemblyScriptPoolOptions;
+    };
+  };
+};
+/**
+* Root-level config type with AssemblyScript pool support
+*/
+type AssemblyScriptConfigExport = AssemblyScriptUserConfig<ViteUserConfig>;
+/**
+* Project-level config type with AssemblyScript pool support
+*/
+type AssemblyScriptProjectConfigExport = AssemblyScriptUserConfig<UserWorkspaceConfig>;
+/**
+* Define a root-level Vitest config with AssemblyScript pool options.
+*
+* This is a type-safe wrapper that properly types `poolOptions.assemblyScript`
+* for both root and project-level configurations.
+*
+* @example
+* ```ts
+* import { defineAssemblyScriptConfig } from 'vitest-pool-assemblyscript/config';
+*
+* export default defineAssemblyScriptConfig({
+*   test: {
+*     name: 'assemblyscript-unit-tests',
+*     pool: 'vitest-pool-assemblyscript',
+*     include: ['test/assembly/**‍/*.as.test.ts'], // example
+*     poolOptions: {
+*       assemblyScript: { // optional },
+*     },
+*     coverage: {
+*       provider: 'custom',
+*       customProviderModule: 'vitest-pool-assemblyscript/coverage',
+*       include: ['src/**‍/*.ts'],  // example JS/TS sources (v8 provider)
+*       assemblyScriptInclude: ['assembly/**‍/*.ts'],  // example AS sources
+*       assemblyScriptExclude: ['**‍/*.as.test.ts'],   // exclude AS test files
+*     },
+*   },
+* });
+* ```
+*/
+declare function defineAssemblyScriptConfig(config: AssemblyScriptConfigExport): AssemblyScriptConfigExport;
+declare function defineAssemblyScriptConfig(config: Promise<AssemblyScriptConfigExport>): Promise<AssemblyScriptConfigExport>;
+declare function defineAssemblyScriptConfig(config: (env: ConfigEnv) => AssemblyScriptConfigExport | Promise<AssemblyScriptConfigExport>): (env: ConfigEnv) => AssemblyScriptConfigExport | Promise<AssemblyScriptConfigExport>;
+/**
+* Define a project-level Vitest config with AssemblyScript pool options.
+*
+* Use this when defining AssemblyScript test projects within a workspace.
+*
+* @example
+* ```ts
+* import { defineConfig, defineProject } from 'vitest/config';
+* import { defineAssemblyScriptProject } from 'vitest-pool-assemblyscript/config';
+*
+* export default defineConfig({
+*   test: {
+*     projects: [
+*       defineProject({
+*         test: {
+*           name: { label: 'typescript-unit-tests', color: 'blue' },
+*         }
+*       }),
+*       defineAssemblyScriptProject({
+*         test: {
+*           name: { label: 'assemblyscript-unit-tests', color: 'yellow' },
+*           pool: 'vitest-pool-assemblyscript',
+*           include: ['test/assembly/**‍/*.as.test.ts'], // example
+*           poolOptions: {
+*             assemblyScript: { // optional },
+*           },
+*         },
+*       }),
+*     ],
+*     coverage: {    // coverage section is global only in vitest
+*       provider: 'custom',
+*       customProviderModule: 'vitest-pool-assemblyscript/coverage',
+*       include: ['src/**‍/*.ts'],  // example JS/TS sources (v8 provider)
+*       assemblyScriptInclude: ['assembly/**‍/*.ts'],  // example AS sources
+*       assemblyScriptExclude: ['**‍/*.as.test.ts'],   // exclude AS test files
+*     },
+*   },
+* });
+* ```
+*/
+declare function defineAssemblyScriptProject(config: AssemblyScriptProjectConfigExport): AssemblyScriptProjectConfigExport;
+declare function defineAssemblyScriptProject(config: Promise<AssemblyScriptProjectConfigExport>): Promise<AssemblyScriptProjectConfigExport>;
+declare function defineAssemblyScriptProject(config: (env: ConfigEnv) => AssemblyScriptProjectConfigExport | Promise<AssemblyScriptProjectConfigExport>): (env: ConfigEnv) => AssemblyScriptProjectConfigExport | Promise<AssemblyScriptProjectConfigExport>;
+//#endregion
+export { AssemblyScriptConfigExport, type AssemblyScriptPoolOptions, AssemblyScriptProjectConfigExport, AssemblyScriptUserConfig, type WasmImportsFactory, type WasmImportsFactoryInfo, defineAssemblyScriptConfig, defineAssemblyScriptProject };
+//# sourceMappingURL=index-v3.d.mts.map

package/dist/config/index-v3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-v3.d.mts","names":[],"sources":["../../src/config/config-helpers-v3.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAgCY,wBAAA,WAAmC,cAAA,IAAkB,CAAA;EAC/D,IAAA;IAEE,WAAA;MACE,cAAA,GAAiB,yBAAA;IAAA;EAAA;AAAA;;;;KAQX,0BAAA,GAA6B,wBAAA,CAAyB,cAAA;AAoClE;;;AAAA,KA/BY,iCAAA,GAAoC,wBAAA,CAAyB,mBAAA;;;;;;AAkCzE;;;;;;;;;;;;;;;;AAGA;;;;;;;;iBANgB,0BAAA,CACd,MAAA,EAAQ,0BAAA,GACP,0BAAA;AAAA,iBACa,0BAAA,CACd,MAAA,EAAQ,OAAA,CAAQ,0BAAA,IACf,OAAA,CAAQ,0BAAA;AAAA,iBACK,0BAAA,CACd,MAAA,GAAS,GAAA,EAAK,SAAA,KAAc,0BAAA,GAA6B,OAAA,CAAQ,0BAAA,KAC/D,GAAA,EAAK,SAAA,KAAc,0BAAA,GAA6B,OAAA,CAAQ,0BAAA;;;;;;;;;;;;;;;;AAgD5D;;;;;;;;;AAGA;;;;;;;;;;;;;;;;iBAHgB,2BAAA,CACd,MAAA,EAAQ,iCAAA,GACP,iCAAA;AAAA,iBACa,2BAAA,CACd,MAAA,EAAQ,OAAA,CAAQ,iCAAA,IACf,OAAA,CAAQ,iCAAA;AAAA,iBACK,2BAAA,CACd,MAAA,GAAS,GAAA,EAAK,SAAA,KAAc,iCAAA,GAAoC,OAAA,CAAQ,iCAAA,KACtE,GAAA,EAAK,SAAA,KAAc,iCAAA,GAAoC,OAAA,CAAQ,iCAAA"}

package/dist/config/index-v3.mjs

@@ -0,0 +1,11 @@
+//#region src/config/config-helpers-v3.ts
+function defineAssemblyScriptConfig(config) {
+	return config;
+}
+function defineAssemblyScriptProject(config) {
+	return config;
+}
+
+//#endregion
+export { defineAssemblyScriptConfig, defineAssemblyScriptProject };
+//# sourceMappingURL=index-v3.mjs.map

package/dist/config/index-v3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-v3.mjs","names":[],"sources":["../../src/config/config-helpers-v3.ts"],"sourcesContent":["/**\n * Configuration helpers for vitest-pool-assemblyscript\n *\n * Provides custom type-safe config helpers similar to Cloudflare's vitest-pool-workers\n * to work around TypeScript's ProjectConfig poolOptions type narrowing in Vitest v3.\n */\n\nimport type { ViteUserConfig, UserWorkspaceConfig, ConfigEnv } from 'vitest/config';\n\nimport type { AssemblyScriptPoolOptions } from '../types/types.js';\n\n/**\n * Type for config that may be a value, Promise, or function\n */\ntype AnyConfigExport<T extends ViteUserConfig> =\n  | T\n  | Promise<T>\n  | ((env: ConfigEnv) => T | Promise<T>);\n\n/**\n * AssemblyScript pool configuration with proper typing for poolOptions\n *\n * Use this type with `defineAssemblyScriptConfig` for root-level configs,\n * or `defineAssemblyScriptProject` for project-level configs.\n * \n * Vitest v3's ProjectConfig narrows poolOptions as an inline object type,\n * which cannot be augmented via TypeScript module augmentation. Config helpers\n * use type intersection to add poolOptions.assemblyScript typing.\n *\n * Note: Coverage is NOT included here because it's global-only config in Vitest.\n * Coverage typing comes from the CustomProviderOptions augmentation above.\n */\nexport type AssemblyScriptUserConfig<T extends ViteUserConfig> = T & {\n  test?: {\n    // pool?: string;\n    poolOptions?: {\n      assemblyScript?: AssemblyScriptPoolOptions;\n    };\n  };\n};\n\n/**\n * Root-level config type with AssemblyScript pool support\n */\nexport type AssemblyScriptConfigExport = AssemblyScriptUserConfig<ViteUserConfig>;\n\n/**\n * Project-level config type with AssemblyScript pool support\n */\nexport type AssemblyScriptProjectConfigExport = AssemblyScriptUserConfig<UserWorkspaceConfig>;\n\n/**\n * Define a root-level Vitest config with AssemblyScript pool options.\n *\n * This is a type-safe wrapper that properly types `poolOptions.assemblyScript`\n * for both root and project-level configurations.\n *\n * @example\n * ```ts\n * import { defineAssemblyScriptConfig } from 'vitest-pool-assemblyscript/config';\n *\n * export default defineAssemblyScriptConfig({\n *   test: {\n *     name: 'assemblyscript-unit-tests',\n *     pool: 'vitest-pool-assemblyscript',\n *     include: ['test/assembly/**‍/*.as.test.ts'], // example\n *     poolOptions: {\n *       assemblyScript: { // optional },\n *     },\n *     coverage: {\n *       provider: 'custom',\n *       customProviderModule: 'vitest-pool-assemblyscript/coverage',\n *       include: ['src/**‍/*.ts'],  // example JS/TS sources (v8 provider)\n *       assemblyScriptInclude: ['assembly/**‍/*.ts'],  // example AS sources\n *       assemblyScriptExclude: ['**‍/*.as.test.ts'],   // exclude AS test files\n *     },\n *   },\n * });\n * ```\n */\nexport function defineAssemblyScriptConfig(\n  config: AssemblyScriptConfigExport\n): AssemblyScriptConfigExport;\nexport function defineAssemblyScriptConfig(\n  config: Promise<AssemblyScriptConfigExport>\n): Promise<AssemblyScriptConfigExport>;\nexport function defineAssemblyScriptConfig(\n  config: (env: ConfigEnv) => AssemblyScriptConfigExport | Promise<AssemblyScriptConfigExport>\n): (env: ConfigEnv) => AssemblyScriptConfigExport | Promise<AssemblyScriptConfigExport>;\nexport function defineAssemblyScriptConfig(\n  config: AnyConfigExport<AssemblyScriptConfigExport>\n): AnyConfigExport<AssemblyScriptConfigExport> {\n  // Pass through - this is just for type safety\n  return config;\n}\n\n/**\n * Define a project-level Vitest config with AssemblyScript pool options.\n *\n * Use this when defining AssemblyScript test projects within a workspace.\n *\n * @example\n * ```ts\n * import { defineConfig, defineProject } from 'vitest/config';\n * import { defineAssemblyScriptProject } from 'vitest-pool-assemblyscript/config';\n *\n * export default defineConfig({\n *   test: {\n *     projects: [\n *       defineProject({\n *         test: {\n *           name: { label: 'typescript-unit-tests', color: 'blue' },\n *         }\n *       }),\n *       defineAssemblyScriptProject({\n *         test: {\n *           name: { label: 'assemblyscript-unit-tests', color: 'yellow' },\n *           pool: 'vitest-pool-assemblyscript',\n *           include: ['test/assembly/**‍/*.as.test.ts'], // example\n *           poolOptions: {\n *             assemblyScript: { // optional },\n *           },\n *         },\n *       }),\n *     ],\n *     coverage: {    // coverage section is global only in vitest\n *       provider: 'custom',\n *       customProviderModule: 'vitest-pool-assemblyscript/coverage',\n *       include: ['src/**‍/*.ts'],  // example JS/TS sources (v8 provider)\n *       assemblyScriptInclude: ['assembly/**‍/*.ts'],  // example AS sources\n *       assemblyScriptExclude: ['**‍/*.as.test.ts'],   // exclude AS test files\n *     },\n *   },\n * });\n * ```\n */\nexport function defineAssemblyScriptProject(\n  config: AssemblyScriptProjectConfigExport\n): AssemblyScriptProjectConfigExport;\nexport function defineAssemblyScriptProject(\n  config: Promise<AssemblyScriptProjectConfigExport>\n): Promise<AssemblyScriptProjectConfigExport>;\nexport function defineAssemblyScriptProject(\n  config: (env: ConfigEnv) => AssemblyScriptProjectConfigExport | Promise<AssemblyScriptProjectConfigExport>\n): (env: ConfigEnv) => AssemblyScriptProjectConfigExport | Promise<AssemblyScriptProjectConfigExport>;\nexport function defineAssemblyScriptProject(\n  config: AnyConfigExport<AssemblyScriptProjectConfigExport>\n): AnyConfigExport<AssemblyScriptProjectConfigExport> {\n  // Pass through - this is just for type safety\n  return config;\n}\n"],"mappings":";AAyFA,SAAgB,2BACd,QAC6C;AAE7C,QAAO;;AAoDT,SAAgB,4BACd,QACoD;AAEpD,QAAO"}

package/dist/config/index.d.mts

@@ -0,0 +1,4 @@
+import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-8KKo9Hbf.mjs";
+import "../custom-provider-options-CF5C1kXb.mjs";
+import { createAssemblyScriptPool } from "../pool-runner-init-CEwLyNI3.mjs";
+export { type AssemblyScriptPoolOptions, type WasmImportsFactory, type WasmImportsFactoryInfo, createAssemblyScriptPool };

package/dist/config/index.mjs

@@ -0,0 +1,8 @@
+import "../resolve-config-as1w-Qyz.mjs";
+import "../debug-IeEHsxy0.mjs";
+import "../vitest-file-tasks-BUwzh375.mjs";
+import "../vitest-tasks-BKS7689f.mjs";
+import "../worker-rpc-channel-lbhK7Qz8.mjs";
+import { createAssemblyScriptPool } from "../pool-runner-init-d5qScS41.mjs";
+
+export { createAssemblyScriptPool };

package/dist/constants-CA50WBdr.mjs

@@ -0,0 +1,130 @@
+//#region src/types/constants.ts
+const COVERAGE_PAYLOAD_FORMATS = { AssemblyScript: "assemblyscript" };
+/** Paths instrumentation exclusions and assetion error stack frame filtering */
+const POOL_INTERNAL_PATHS = [
+	"assembly/compare.ts",
+	"assembly/describe.ts",
+	"assembly/expect.ts",
+	"assembly/index.ts",
+	"assembly/options.ts",
+	"assembly/test.ts"
+];
+/** Error names for AssemblyScript test failures reported to vitest */
+const TEST_ERROR_NAMES = {
+	AssertionError: "AssertionError",
+	WASMRuntimeError: "WASMRuntimeError"
+};
+/** Error names for internal AssemblyScript pool failures */
+const POOL_ERROR_NAMES = {
+	CompilationError: "CompilationError",
+	WASMInstrumentationError: "WASMInstrumentationError",
+	WASMExecutionHarnessError: "WASMExecutionHarnessError",
+	HybridCoverageProviderError: "HybridCoverageProviderError",
+	PoolReportingError: "PoolReportingError",
+	PoolConfigError: "PoolConfigError",
+	PoolError: "PoolError",
+	PoolSyntaxError: "PoolSyntaxError",
+	PoolRunAbortedError: "PoolRunAbortedError",
+	WASMExecutionAbortError: "WASMExecutionAbortError",
+	WASMExecutionTimeoutError: "WASMExecutionTimeoutError"
+};
+const ASCommonFlags = {
+	Static: 32,
+	Get: 2048,
+	Set: 4096
+};
+const ASNodeKind = {
+	Source: 0,
+	NamedType: 1,
+	FunctionType: 2,
+	TypeName: 3,
+	TypeParameter: 4,
+	Parameter: 5,
+	Identifier: 6,
+	Assertion: 7,
+	Binary: 8,
+	Call: 9,
+	Class: 10,
+	Comma: 11,
+	ElementAccess: 12,
+	False: 13,
+	Function: 14,
+	InstanceOf: 15,
+	Literal: 16,
+	New: 17,
+	Null: 18,
+	Omitted: 19,
+	Parenthesized: 20,
+	PropertyAccess: 21,
+	Ternary: 22,
+	Super: 23,
+	This: 24,
+	True: 25,
+	Constructor: 26,
+	UnaryPostfix: 27,
+	UnaryPrefix: 28,
+	Compiled: 29,
+	Block: 30,
+	Break: 31,
+	Continue: 32,
+	Do: 33,
+	Empty: 34,
+	Export: 35,
+	ExportDefault: 36,
+	ExportImport: 37,
+	Expression: 38,
+	For: 39,
+	ForOf: 40,
+	If: 41,
+	Import: 42,
+	Return: 43,
+	Switch: 44,
+	Throw: 45,
+	Try: 46,
+	Variable: 47,
+	Void: 48,
+	While: 49,
+	Module: 50,
+	ClassDeclaration: 51,
+	EnumDeclaration: 52,
+	EnumValueDeclaration: 53,
+	FieldDeclaration: 54,
+	FunctionDeclaration: 55,
+	ImportDeclaration: 56,
+	InterfaceDeclaration: 57,
+	MethodDeclaration: 58,
+	NamespaceDeclaration: 59,
+	TypeDeclaration: 60,
+	VariableDeclaration: 61,
+	Decorator: 62,
+	ExportMember: 63,
+	SwitchCase: 64,
+	IndexSignature: 65,
+	Comment: 66
+};
+const ASDecoratorKind = {
+	Custom: 0,
+	Global: 1,
+	Operator: 2,
+	OperatorBinary: 3,
+	OperatorPrefix: 4,
+	OperatorPostfix: 5,
+	Unmanaged: 6,
+	Final: 7,
+	Inline: 8,
+	External: 9,
+	ExternalJs: 10,
+	Builtin: 11,
+	Lazy: 12,
+	Unsafe: 13
+};
+const ASSourceKind = {
+	User: 0,
+	UserEntry: 1,
+	Library: 2,
+	LibraryEntry: 3
+};
+
+//#endregion
+export { ASCommonFlags, ASDecoratorKind, ASNodeKind, ASSourceKind, COVERAGE_PAYLOAD_FORMATS, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS, TEST_ERROR_NAMES };
+//# sourceMappingURL=constants-CA50WBdr.mjs.map

package/dist/constants-CA50WBdr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants-CA50WBdr.mjs","names":[],"sources":["../src/types/constants.ts"],"sourcesContent":["/**\n * Plain Constants\n * \n * Only things that don't require importing ./types to avoid circular dependencies.\n */\n\n\n// ============================================================================\n// General / Shared Constants\n// ============================================================================\n\nexport const ASSEMBLYSCRIPT_POOL_NAME = 'assemblyscript' as const;\n\nexport const AS_POOL_ERROR_TYPE_FLAG = '__as_pool__' as const;\n\nexport const AS_POOL_WORKER_MSG_FLAG = '__as_pool__' as const;\n\nexport const AS_POOL_WASM_IMPORTS_ENV = '__as_pool_env__' as const;\n\nexport const VITEST_WORKER_REQUEST_MSG_FLAG = '__vitest_worker_request__' as const;\n\nexport const VITEST_WORKER_RESPONSE_MSG_FLAG = '__vitest_worker_response__' as const;\n\nexport const COVERAGE_PAYLOAD_FORMATS = {\n  AssemblyScript: 'assemblyscript',\n} as const;\n\n/** Prefix for AssemblyScript compiler strip-inline exclusions and instrumentation exclusions */\nexport const ASSEMBLYSCRIPT_LIB_PREFIX = '~lib/' as const;\n\n/** Paths instrumentation exclusions and assetion error stack frame filtering */\nexport const POOL_INTERNAL_PATHS: string[] = [\n  'assembly/compare.ts',\n  'assembly/describe.ts',\n  'assembly/expect.ts',\n  'assembly/index.ts',\n  'assembly/options.ts',\n  'assembly/test.ts',\n] as const;\n\n/** Error names for AssemblyScript test failures reported to vitest */\nexport const TEST_ERROR_NAMES = {\n  /** Assertion evaluated to false within a test function */\n  AssertionError: 'AssertionError',\n  /** WASM runtime called abort after a non-planned user code error */\n  WASMRuntimeError: 'WASMRuntimeError',\n} as const;\n\n/** Error names for internal AssemblyScript pool failures */\nexport const POOL_ERROR_NAMES = {\n  /** AssemblyScript compiler (asc) error */\n  CompilationError: 'CompilationError',\n  /** Native instrumentation and debug info extraction error */\n  WASMInstrumentationError: 'WASMInstrumentationError',\n  /** Unexpected WASM execution error (not a known test error path) */\n  WASMExecutionHarnessError: 'WASMExecutionHarnessError',\n  /** Hybrid coverage provider error */\n  HybridCoverageProviderError: 'HybridCoverageProviderError',\n  /** vitest RPC reporting error */\n  PoolReportingError: 'PoolReportingError',\n  /** User configuration error */\n  PoolConfigError: 'PoolConfigError',\n  /** Generic AssemblyScript pool error */\n  PoolError: 'PoolError',\n  /** User syntax error in test/suite/expect */\n  PoolSyntaxError: 'PoolSyntaxError',\n\n  /** Flow Control: Indicates intentional abort */\n  PoolRunAbortedError: 'PoolRunAbortedError',\n  /**\n   * Flow Control: Indicates WASM execution halt through abort() handler,\n   * and should be handled by reporting an AssemblyScriptTestError to vitest\n   */\n  WASMExecutionAbortError: 'WASMExecutionAbortError',\n  /** Flow Control: Indicates WASM execution halt because test timeout elapsed */\n  WASMExecutionTimeoutError: 'WASMExecutionTimeoutError',\n} as const;\n\n// ============================================================================\n// AssemblyScript Compiler\n// ============================================================================\n\n// Redefined locally to avoid isolatedModules const enum access issues\n// with assemmblyscript enum exports. Reference assemblyscript.generated.d.ts\n\nexport const ASCommonFlags = {\n  Static: 32,\n  Get: 2048,\n  Set: 4096,\n} as const;\n\nexport const ASNodeKind = {\n  Source: 0,\n  NamedType: 1,\n  FunctionType: 2,\n  TypeName: 3,\n  TypeParameter: 4,\n  Parameter: 5,\n  Identifier: 6,\n  Assertion: 7,\n  Binary: 8,\n  Call: 9,\n  Class: 10,\n  Comma: 11,\n  ElementAccess: 12,\n  False: 13,\n  Function: 14,\n  InstanceOf: 15,\n  Literal: 16,\n  New: 17,\n  Null: 18,\n  Omitted: 19,\n  Parenthesized: 20,\n  PropertyAccess: 21,\n  Ternary: 22,\n  Super: 23,\n  This: 24,\n  True: 25,\n  Constructor: 26,\n  UnaryPostfix: 27,\n  UnaryPrefix: 28,\n  Compiled: 29,\n  Block: 30,\n  Break: 31,\n  Continue: 32,\n  Do: 33,\n  Empty: 34,\n  Export: 35,\n  ExportDefault: 36,\n  ExportImport: 37,\n  Expression: 38,\n  For: 39,\n  ForOf: 40,\n  If: 41,\n  Import: 42,\n  Return: 43,\n  Switch: 44,\n  Throw: 45,\n  Try: 46,\n  Variable: 47,\n  Void: 48,\n  While: 49,\n  Module: 50,\n  ClassDeclaration: 51,\n  EnumDeclaration: 52,\n  EnumValueDeclaration: 53,\n  FieldDeclaration: 54,\n  FunctionDeclaration: 55,\n  ImportDeclaration: 56,\n  InterfaceDeclaration: 57,\n  MethodDeclaration: 58,\n  NamespaceDeclaration: 59,\n  TypeDeclaration: 60,\n  VariableDeclaration: 61,\n  Decorator: 62,\n  ExportMember: 63,\n  SwitchCase: 64,\n  IndexSignature: 65,\n  Comment: 66,\n} as const;\n\nexport const ASDecoratorKind = {\n  Custom: 0,\n  Global: 1,\n  Operator: 2,\n  OperatorBinary: 3,\n  OperatorPrefix: 4,\n  OperatorPostfix: 5,\n  Unmanaged: 6,\n  Final: 7,\n  Inline: 8,\n  External: 9,\n  ExternalJs: 10,\n  Builtin: 11,\n  Lazy: 12,\n  Unsafe: 13\n} as const;\n\nexport const ASSourceKind = {\n  User: 0,\n  UserEntry: 1,\n  Library: 2,\n  LibraryEntry: 3\n} as const;\n"],"mappings":";AAuBA,MAAa,2BAA2B,EACtC,gBAAgB,kBACjB;;AAMD,MAAa,sBAAgC;CAC3C;CACA;CACA;CACA;CACA;CACA;CACD;;AAGD,MAAa,mBAAmB;CAE9B,gBAAgB;CAEhB,kBAAkB;CACnB;;AAGD,MAAa,mBAAmB;CAE9B,kBAAkB;CAElB,0BAA0B;CAE1B,2BAA2B;CAE3B,6BAA6B;CAE7B,oBAAoB;CAEpB,iBAAiB;CAEjB,WAAW;CAEX,iBAAiB;CAGjB,qBAAqB;CAKrB,yBAAyB;CAEzB,2BAA2B;CAC5B;AASD,MAAa,gBAAgB;CAC3B,QAAQ;CACR,KAAK;CACL,KAAK;CACN;AAED,MAAa,aAAa;CACxB,QAAQ;CACR,WAAW;CACX,cAAc;CACd,UAAU;CACV,eAAe;CACf,WAAW;CACX,YAAY;CACZ,WAAW;CACX,QAAQ;CACR,MAAM;CACN,OAAO;CACP,OAAO;CACP,eAAe;CACf,OAAO;CACP,UAAU;CACV,YAAY;CACZ,SAAS;CACT,KAAK;CACL,MAAM;CACN,SAAS;CACT,eAAe;CACf,gBAAgB;CAChB,SAAS;CACT,OAAO;CACP,MAAM;CACN,MAAM;CACN,aAAa;CACb,cAAc;CACd,aAAa;CACb,UAAU;CACV,OAAO;CACP,OAAO;CACP,UAAU;CACV,IAAI;CACJ,OAAO;CACP,QAAQ;CACR,eAAe;CACf,cAAc;CACd,YAAY;CACZ,KAAK;CACL,OAAO;CACP,IAAI;CACJ,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,OAAO;CACP,KAAK;CACL,UAAU;CACV,MAAM;CACN,OAAO;CACP,QAAQ;CACR,kBAAkB;CAClB,iBAAiB;CACjB,sBAAsB;CACtB,kBAAkB;CAClB,qBAAqB;CACrB,mBAAmB;CACnB,sBAAsB;CACtB,mBAAmB;CACnB,sBAAsB;CACtB,iBAAiB;CACjB,qBAAqB;CACrB,WAAW;CACX,cAAc;CACd,YAAY;CACZ,gBAAgB;CAChB,SAAS;CACV;AAED,MAAa,kBAAkB;CAC7B,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,gBAAgB;CAChB,gBAAgB;CAChB,iBAAiB;CACjB,WAAW;CACX,OAAO;CACP,QAAQ;CACR,UAAU;CACV,YAAY;CACZ,SAAS;CACT,MAAM;CACN,QAAQ;CACT;AAED,MAAa,eAAe;CAC1B,MAAM;CACN,WAAW;CACX,SAAS;CACT,cAAc;CACf"}