vitest-pool-assemblyscript 0.2.0

package/dist/coverage-provider/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["parsePath","AssemblyScriptParser","resolve"],"sources":["../../src/coverage-provider/containment-matcher.ts","../../src/coverage-provider/istanbul-converter.ts","../../src/coverage-provider/ast-parser.ts","../../src/coverage-provider/glob-utils.ts","../../src/coverage-provider/hybrid-coverage-provider.ts","../../src/coverage-provider/index.ts"],"sourcesContent":["/**\n * Containment Matcher\n *\n * Provides containment-based matching for coverage mapping.\n * Binary debug info provides points (representativeLocation), source parsing provides ranges.\n * We find which source range contains each binary point.\n *\n * Usage by version:\n * - v1: Function containment matching (binary representativeLocation → source function range)\n * - v2: Function containment (same) + statement containment + branch path containment\n *\n * Why containment matching (not direct position lookup):\n * AS compiler generates source map entries differently by statement type:\n * - Variable declarations: source map points to statement start (keyword)\n * - Control flow (if/switch/for): source map points to condition EXPRESSION, not keyword\n *\n * Example: `if (n < 0)` → binary reports column 7 ('n'), not column 3 ('i' of 'if')\n *\n * Containment matching is more robust:\n * - Binary gives us a position (representativeLocation) somewhere in the function\n * - Source gives us function ranges (start/end line/column)\n * - We find which source function range contains the binary position\n * - Handles nested functions with \"tightest fit\" (innermost function wins)\n */\n\nimport type { ParsedSourceFunctionInfo, SourceRange } from '../types/types.js';\n\n/**\n * Functions indexed by file path, then by start line.\n * Multiple functions can start on the same line (e.g., nested arrow functions).\n */\nexport type FunctionsByFileAndStartLine = Record<string, Record<number, ParsedSourceFunctionInfo[]>>;\n\n/**\n * Find the source function whose range contains the given position.\n *\n * For nested functions, uses \"tightest fit\" - returns the innermost function\n * (the one with the largest start position among all containing functions).\n *\n * @param functionsByStartLine - Functions for a single file, indexed by start line\n * @param line - Target line number (1-based)\n * @param column - Target column number (1-based)\n * @returns The containing function, or undefined if no match\n */\nexport function findFunctionContainingPosition(\n  functionsByStartLine: Record<number, ParsedSourceFunctionInfo[]>,\n  line: number,\n  column: number\n): ParsedSourceFunctionInfo | undefined {\n  let bestMatch: ParsedSourceFunctionInfo | undefined;\n  let bestStartLine = -1;\n  let bestStartColumn = -1;\n\n  // Check functions starting on lines <= target line\n  for (const [startLineStr, functions] of Object.entries(functionsByStartLine)) {\n    const startLine = Number(startLineStr);\n    if (startLine > line) continue;\n\n    for (const func of functions) {\n      const { range } = func;\n\n      // Check if position is within this function's range\n      if (!isPositionInRange(line, column, range)) continue;\n\n      // Tightest fit: prefer function with largest start position (innermost)\n      if (startLine > bestStartLine ||\n          (startLine === bestStartLine && range.startColumn > bestStartColumn)) {\n        bestMatch = func;\n        bestStartLine = startLine;\n        bestStartColumn = range.startColumn;\n      }\n    }\n  }\n\n  return bestMatch;\n}\n\n/**\n * Check if a position (line, column) falls within a source range.\n *\n * @param line - Target line number (1-based)\n * @param column - Target column number (1-based)\n * @param range - Source range to check against\n * @returns true if position is within range (inclusive)\n */\nexport function isPositionInRange(\n  line: number,\n  column: number,\n  range: SourceRange\n): boolean {\n  // Outside line range entirely\n  if (line < range.startLine || line > range.endLine) return false;\n\n  // On start line but before start column\n  if (line === range.startLine && column < range.startColumn) return false;\n\n  // On end line but after end column\n  if (line === range.endLine && column > range.endColumn) return false;\n\n  return true;\n}\n","/**\n * Istanbul Format Converter\n *\n * Converts AssemblyScript coverage data to Istanbul's FileCoverageData format.\n * This enables integration with Vitest's coverage reporting system and standard\n * coverage tools like Codecov, Coveralls, etc.\n *\n * Current Implementation: Function-level coverage only\n * - Uses containment matching: binary positions → source function ranges\n * - Each function maps to both a function entry AND a statement entry\n * - Statement coverage matches function coverage (function-level granularity)\n * - Branch coverage is 0% (no branches tracked yet)\n * - Line coverage derived from statement coverage\n *\n * Future Enhancement (v2): Block-level statement and branch coverage\n */\n\nimport type { FileCoverageData, Range, FunctionMapping, BranchMapping } from 'istanbul-lib-coverage';\nimport type { ParsedSourceFunctionInfo } from '../types/types.js';\nimport { findFunctionContainingPosition } from './containment-matcher.js';\nimport { debug } from '../util/debug.js';\n\nconst DEBUG_ISTANBUL = false;\n\nfunction istanbulDebug(...args: any[]): void {\n  if (DEBUG_ISTANBUL) {\n    debug(...args);\n  }\n};\n\n/**\n * Convert AssemblyScript coverage data to Istanbul format for a single file\n *\n * Algorithm (containment matching):\n * 1. For each hit position in fileHitCountsByPosition:\n *    - Use containment matcher to find which source function contains this position\n *    - Record the hit count for that function\n * 2. For each function in fileFunctionsByStartLine:\n *    - Add function mapping to fnMap\n *    - Add function hit count to f (from matched hits, or 0 if not hit)\n *    - Add corresponding statement mapping to statementMap\n *    - Add same hit count to s (statement coverage matches function coverage)\n *\n * @param fileFunctionsByStartLine - Functions for this file, keyed by start line (from AST parser)\n * @param fileHitCountsByPosition - Hit counts for this file, keyed by position \"line:column\" (from accumulated coverage)\n * @param absoluteFilePath - Absolute path to the source file (for Istanbul output)\n * @returns Istanbul FileCoverage object\n */\nexport async function convertToIstanbulFormat(\n  fileFunctionsByStartLine: Record<number, ParsedSourceFunctionInfo[]>,\n  fileHitCountsByPosition: Record<string, number>,\n  absoluteFilePath: string\n): Promise<FileCoverageData> {\n  const startMatch = performance.now();\n\n  istanbulDebug(() => {\n    const sourceFunctionCount = Object.values(fileFunctionsByStartLine).reduce((sum, funcs) => sum + funcs.length, 0);\n    const uniqueHitPosCount = Object.keys(fileHitCountsByPosition).length;\n    const coverageEstimate = sourceFunctionCount === 0 ? Infinity : ((uniqueHitPosCount * 100) / sourceFunctionCount).toFixed(2);\n\n    return `[IstanbulConverter]   Processing source file: \"${absoluteFilePath}\"\\n`\n    + `[IstanbulConverter]   Source: ${sourceFunctionCount} total functions, Coverage: ${uniqueHitPosCount} unique hit positions\\n`\n    + `[IstanbulConverter]   Sanity Check - AS File Coverage Estimate: ${coverageEstimate}%\\n`\n    + `[IstanbulConverter]   Containment matching functions: coverage hit positions to source functions by range`;\n  });\n\n  // Build a map of function → hit count using containment matching\n  // Key: function source identity (qualifiedName), Value: hit count\n  const hitCountsBySourceFunctionName = new Map<ParsedSourceFunctionInfo, number>();\n\n  // For each hit position, find which function contains it\n  for (const [positionKey, hitCount] of Object.entries(fileHitCountsByPosition)) {\n    // Position key format is \"line:column\"\n    const parts = positionKey.split(':');\n    const lineStr = parts[0];\n    const columnStr = parts[1];\n\n    if (lineStr && columnStr) {\n      const line = parseInt(lineStr, 10);\n      const column = parseInt(columnStr, 10);\n\n      const containingFunction = findFunctionContainingPosition(fileFunctionsByStartLine, line, column);\n      if (containingFunction) {\n        // Accumulate hits (in case multiple positions map to same function)\n        const existingHits = hitCountsBySourceFunctionName.get(containingFunction);\n        const existingHitsCount = existingHits ?? 0;\n        const max = Math.max(existingHitsCount, hitCount);\n        hitCountsBySourceFunctionName.set(containingFunction, max); // <-- TODO: Explain this max logic\n\n        if (existingHits !== undefined) {\n          istanbulDebug(`[IstanbulConverter]     Position ${positionKey} → function \"${containingFunction.shortName}\" EXISTING HITS: ${existingHits} NEW COUNT: ${max}`);\n        } else {\n          istanbulDebug(`[IstanbulConverter]     Position ${positionKey} → function \"${containingFunction.shortName}\" (hits: ${hitCount})`);\n        }\n      } else {\n        istanbulDebug(`[IstanbulConverter]     Position ${positionKey} has no containing function`);\n      }\n    }\n  }\n\n  const startConvert = performance.now();\n  istanbulDebug(`[IstanbulConverter]   Matching Complete - Converting to Istanbul format`);\n\n  // Initialize Istanbul data structures\n  const fnMap: { [key: string]: FunctionMapping } = {};\n  const f: { [key: string]: number } = {};\n  const statementMap: { [key: string]: Range } = {};\n  const s: { [key: string]: number } = {};\n  const branchMap: { [key: string]: BranchMapping } = {};\n  const b: { [key: string]: number[] } = {};\n\n  // Convert function coverage to Istanbul format\n  // Iterate all functions from parsed source (ensures 0-hit functions are included)\n  let funcIdx = 0;\n  for (const functions of Object.values(fileFunctionsByStartLine)) {\n    for (const funcInfo of functions) {\n      const { range, shortName } = funcInfo;\n\n      // Defensive: skip functions with invalid metadata (shouldn't happen - AST parser filters these)\n      if (range.startLine === 0) {\n        continue;\n      }\n\n      // Get hit count from containment matching (or 0 if not hit)\n      const hitCount = hitCountsBySourceFunctionName.get(funcInfo) ?? 0;\n      const displayShortName = shortName && shortName !== '' ? shortName : '<anonymous>';\n      istanbulDebug(\n        `[IstanbulConverter]     Istanbul function index ${funcIdx}: \"${displayShortName}\"`\n        + ` (source ${range.startLine}:${range.startColumn} - ${range.endLine}:${range.endColumn}), hits: ${hitCount}`\n      );\n\n      // Create function mapping\n      // Both 'decl' (declaration) and 'loc' (location) use the same range\n      // Internal ParsedSourceFunctionInfo uses 1-based columns, Istanbul expects 0-based\n      const istanbulRange: Range = {\n        start: { line: range.startLine, column: range.startColumn - 1 },\n        end: { line: range.endLine, column: range.endColumn - 1 }\n      };\n\n      const idxStr = funcIdx.toString();\n      fnMap[idxStr] = {\n        name: shortName,\n        decl: istanbulRange,\n        loc: istanbulRange,\n        line: range.startLine\n      };\n      f[idxStr] = hitCount;\n\n      // Create corresponding statement mapping\n      // For function-level coverage, each function is one \"statement\"\n      // The statement range matches the function range\n      // This gives us statement coverage at function granularity\n      statementMap[idxStr] = istanbulRange;\n      s[idxStr] = hitCount;\n\n      funcIdx++;\n    }\n  }\n\n  const done = performance.now();\n  const matchingMs = (startConvert - startMatch).toFixed(2);\n  const convertMs = (done - startConvert).toFixed(2);\n  const totalMs = (done - startMatch).toFixed(2);\n\n  istanbulDebug(\n    `[IstanbulConverter]   Coverage Coversion Complete: ${Object.keys(fnMap).length} functions,` \n    + ` ${totalMs} ms total (matching: ${matchingMs} ms, convert: ${convertMs} ms)`\n  );\n\n  return {\n    path: absoluteFilePath,\n    fnMap,\n    f,\n    statementMap,\n    s,\n    branchMap,\n    b\n  };\n}\n","/**\n * AST Parser for AssemblyScript Source Files\n *\n * Parses AS source files to extract function metadata for coverage.\n * Used by generateCoverage to build empty coverage map from all source files.\n *\n * Source AST is the source of truth for what SHOULD be covered.\n * Binary instrumentation tells us what we CAN measure (hit counts).\n *\n * Functions are grouped by start line for efficient containment matching.\n *\n * Architecture:\n * - Uses shared ASTVisitor for complete NodeKind coverage\n * - Overrides hooks to extract function information during traversal\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { parse as parsePath } from 'node:path';\nimport {\n  Parser as AssemblyScriptParser,\n  Source,\n  BlockStatement,\n  Node,\n  FunctionDeclaration,\n  MethodDeclaration,\n  ClassDeclaration,\n  VariableDeclaration,\n  FunctionExpression,\n} from 'assemblyscript';\n\nimport type { ParsedSourceFunctionInfo, SourceRange } from '../types/types.js';\nimport { ASCommonFlags, ASNodeKind } from '../types/constants.js';\nimport { ASTVisitor } from '../util/ast-visitor.js';\n\n/**\n * Visitor that extracts function information from AST nodes\n */\nclass FunctionExtractorVisitor extends ASTVisitor {\n  /** Source file being parsed */\n  private source: Source;\n  /** Module path for building qualified names */\n  private modulePath: string;\n  /** Absolute file path */\n  private filePath: string;\n  /** Accumulated function records, keyed by start line */\n  readonly functions: Record<number, ParsedSourceFunctionInfo[]> = {};\n  /** Current class name (when inside a class) */\n  private currentClassName: string | null = null;\n\n  constructor(source: Source, modulePath: string, filePath: string) {\n    super();\n    this.source = source;\n    this.modulePath = modulePath;\n    this.filePath = filePath;\n  }\n\n  /**\n   * Track class context when entering a class\n   */\n  protected onClassEnter(node: ClassDeclaration): void {\n    this.currentClassName = node.name?.text ?? 'Anonymous';\n  }\n\n  /**\n   * Restore class context when exiting a class\n   */\n  protected onClassExit(_node: ClassDeclaration): void {\n    this.currentClassName = null;\n  }\n\n  /**\n   * Extract function info from function declarations\n   */\n  protected onFunctionDeclaration(node: FunctionDeclaration): boolean {\n    if (node.body && this.hasBodyStatements(node.body)) {\n      const shortName = node.name?.text ?? '~anonymous';\n      const qualifiedName = `${this.modulePath}/${shortName}`;\n      const range = this.buildRange(node, node.name ?? null);\n      this.addFunction(qualifiedName, shortName, range);\n    }\n    return true; // Continue recursion into body\n  }\n\n  /**\n   * Extract function info from method declarations\n   */\n  protected onMethodDeclaration(node: MethodDeclaration): boolean {\n    if (node.body && this.hasBodyStatements(node.body)) {\n      const methodName = node.name?.text ?? 'constructor';\n      const className = this.currentClassName ?? 'Unknown';\n      const flags = node.flags;\n\n      // Determine method type from flags\n      const isStatic = (flags & ASCommonFlags.Static) !== 0;\n      const isGetter = (flags & ASCommonFlags.Get) !== 0;\n      const isSetter = (flags & ASCommonFlags.Set) !== 0;\n\n      // Build short name to match binary naming convention:\n      // - Static: ClassName.methodName\n      // - Getter: ClassName#get:propertyName\n      // - Setter: ClassName#set:propertyName\n      // - Instance: ClassName#methodName\n      let shortName: string;\n      if (isStatic) {\n        shortName = `${className}.${methodName}`;\n      } else if (isGetter) {\n        shortName = `${className}#get:${methodName}`;\n      } else if (isSetter) {\n        shortName = `${className}#set:${methodName}`;\n      } else {\n        shortName = `${className}#${methodName}`;\n      }\n\n      const qualifiedName = `${this.modulePath}/${shortName}`;\n      const range = this.buildRange(node, node.name ?? null);\n      this.addFunction(qualifiedName, shortName, range);\n    }\n    return true; // Continue recursion into body\n  }\n\n  /**\n   * Extract function info from variable declarations (arrow functions)\n   */\n  protected onVariableDeclaration(node: VariableDeclaration): boolean {\n    if (node.initializer && node.initializer.kind === ASNodeKind.Function) {\n      const funcExpr = node.initializer as FunctionExpression;\n      const funcDecl = funcExpr.declaration;\n\n      if (funcDecl.body && this.hasBodyStatements(funcDecl.body)) {\n        // Use variable name for the function\n        const shortName = node.name.text;\n        const qualifiedName = `${this.modulePath}/${shortName}`;\n\n        // Use the variable declaration's range\n        const range: SourceRange = {\n          filePath: this.filePath,\n          startLine: this.source.lineAt(node.range.start),\n          startColumn: this.source.columnAt(),\n          endLine: this.source.lineAt(node.range.end),\n          endColumn: this.source.columnAt(),\n        };\n\n        this.addFunction(qualifiedName, shortName, range);\n      }\n\n      // Visit the function body manually since we're handling this specially\n      if (funcDecl.body) {\n        this.visitNode(funcDecl.body);\n      }\n      return false; // Don't recurse again - we handled it\n    }\n    return true; // Continue recursion for non-function initializers\n  }\n\n  /**\n   * Check if a function body has statements (non-empty body)\n   */\n  private hasBodyStatements(body: Node): boolean {\n    if (body.kind === ASNodeKind.Block) {\n      const blockBody = body as BlockStatement;\n      return blockBody.statements.length > 0;\n    }\n    // Expression body (braceless arrow) - always has the expression\n    return true;\n  }\n\n  /**\n   * Add a function to the functions record, keyed by start line\n   */\n  private addFunction(qualifiedName: string, shortName: string, range: SourceRange): void {\n    const startLine = range.startLine;\n    if (!this.functions[startLine]) {\n      this.functions[startLine] = [];\n    }\n    this.functions[startLine].push({ qualifiedName, shortName, range });\n  }\n\n  /**\n   * Build a SourceRange for a node, using name.range.start to skip decorators\n   */\n  private buildRange(node: Node, nameNode: Node | null): SourceRange {\n    const startNode = nameNode ?? node;\n    return {\n      filePath: this.filePath,\n      startLine: this.source.lineAt(startNode.range.start),\n      startColumn: this.source.columnAt(),\n      endLine: this.source.lineAt(node.range.end),\n      endColumn: this.source.columnAt(),\n    };\n  }\n}\n\n/**\n * Parse functions from a single AS source file\n *\n * @param absoluteSourceFilePath - Absolute path to AS source file\n * @param relativeSourceFilePath - Relative path to AS source file (derived once in caller and used several places)\n * @returns Record of start line to array of ParsedSourceFunctionInfo (multiple functions can start on same line)\n */\nexport async function parseFunctionsFromFile(\n  absoluteSourceFilePath: string,\n  relativeSourceFilePath: string,\n): Promise<Record<number, ParsedSourceFunctionInfo[]>> {\n  const sourceCode = await readFile(absoluteSourceFilePath, 'utf8');\n\n  // Build the module path (strip any extension, use forward slashes)\n  const parsed = parsePath(relativeSourceFilePath);\n  const modulePath = parsed.dir ? `${parsed.dir}/${parsed.name}` : parsed.name;\n\n  // Parse with AssemblyScript parser\n  const asParser = new AssemblyScriptParser();\n  asParser.parseFile(sourceCode, relativeSourceFilePath, true);\n\n  const source = asParser.currentSource;\n  if (!source) {\n    return {};\n  }\n\n  // Create visitor and traverse\n  const visitor = new FunctionExtractorVisitor(source, modulePath, absoluteSourceFilePath);\n  visitor.visitSource(source);\n\n  return visitor.functions || {};\n}\n","/**\n * Glob Utilities for Coverage\n *\n * Uses test-exclude (same as Vitest's v8 coverage provider) to glob\n * AssemblyScript files matching coverage.include patterns.\n */\n\nimport { resolve } from 'path';\nimport TestExclude from 'test-exclude';\n\nimport { GlobResult } from '../types/types.js';\n\n/**\n * Glob files matching coverage include/exclude patterns\n *\n * Uses test-exclude for consistent behavior with Vitest's built-in\n * coverage providers.\n *\n * @param include - Include patterns (e.g., ['assembly/**\\/*.ts'])\n * @param exclude - Exclude patterns (e.g., ['**\\/*.test.ts'])\n * @param projectRoot - Project root directory\n * @returns Array of absolute file paths\n */\nexport function globFiles(\n  include: string[],\n  exclude: string[],\n  projectRoot: string\n): GlobResult[] {\n  // avoid issues with default behavior being grabbing from cwd\n  if (include.length === 0) {\n    return [];\n  }\n\n  const testExclude = new TestExclude({\n    cwd: projectRoot,\n    include,\n    exclude,\n    excludeNodeModules: true,\n  });\n\n  const includedFiles = testExclude.globSync(projectRoot);\n  const results: GlobResult[] = includedFiles.map((file: string) => ({\n    absolute: resolve(projectRoot, file),\n    projectRootRelative: file\n  })) || [];\n\n  return results;\n}\n","/**\n * Hybrid Coverage Provider\n *\n * This provider handles both AssemblyScript and JavaScript and coverage\n * - Converts AS coverage to Istanbul format\n * - Delegates JS coverage to Vitest's v8 provider\n * - Merges both into a unified coverage report\n */\n\nimport { basename, relative } from 'node:path';\nimport type {\n  CoverageProvider,\n  Vitest,\n  ReportContext,\n  ResolvedCoverageOptions,\n  CustomProviderOptions,\n  ResolvedConfig,\n} from 'vitest/node';\nimport type { AfterSuiteRunMeta, SerializedConfig } from 'vitest';\nimport v8CoverageModule from '@vitest/coverage-v8';\nimport { type CoverageMap, createCoverageMap } from 'istanbul-lib-coverage';\n\n// pick up CustomProviderOptions module augmentation\nimport '../config/custom-provider-options.js';\n\nimport { convertToIstanbulFormat } from './istanbul-converter.js';\nimport { parseFunctionsFromFile } from './ast-parser.js';\nimport { globFiles } from './glob-utils.js';\nimport { getProjectSerializedOrGlobalConfig } from '../util/resolve-config.js';\nimport { mergeCoverageData } from './coverage-merge.js';\nimport { debug } from '../util/debug.js';\nimport { createPoolError } from '../util/pool-errors.js';\nimport type {\n  AssemblyScriptCoveragePayload,\n  CoverageData,\n  GlobResult,\n  ResolvedHybridProviderOptions,\n} from '../types/types.js';\nimport {\n  POOL_ERROR_NAMES,\n  COVERAGE_PAYLOAD_FORMATS\n} from '../types/constants.js';\n\nexport class HybridCoverageProvider implements CoverageProvider {\n  name = 'hybrid-assemblyscript-v8' as const;\n\n  private v8Provider: CoverageProvider | undefined;\n  private accumulatedCoverageData: CoverageData = { hitCountsByFileAndPosition: {} };\n  private projectConfig: SerializedConfig | ResolvedConfig = {} as SerializedConfig;\n  private coverageOptions: ResolvedHybridProviderOptions = {} as ResolvedHybridProviderOptions;\n\n  /**\n   * Initialize the provider and get reference to v8 provider\n   */\n  async initialize(ctx: Vitest): Promise<void> {\n    this.projectConfig = getProjectSerializedOrGlobalConfig(ctx).config;\n\n    debug('[HybridCoverageProvider] Initializing Provider');\n\n    // Get v8 provider from the coverage module\n    this.v8Provider = await v8CoverageModule.getProvider();\n\n    if (!this.v8Provider) {\n      throw createPoolError(\n        'HybridCoverageProvider - initialize failed to get delegated v8 provider',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n\n    await this.v8Provider.initialize(ctx);\n    this.v8Provider.name = 'hybrid-assemblyscript-v8 (delegated v8 reporter)' as const;\n    debug('[HybridCoverageProvider] Initialized with delegated v8 provider');\n  }\n\n  /**\n   * Handle suite completion - delegate based on coverage format marker\n   */\n  async onAfterSuiteRun(meta: AfterSuiteRunMeta): Promise<void> {\n    const start = performance.now();\n    const format: string | undefined = (meta?.coverage as any)?.__format;\n    let suiteLogLabel = meta.testFiles.length > 0 ? basename(meta.testFiles[0]!) : '';\n\n    // Check for AssemblyScript format marker\n    if (format === COVERAGE_PAYLOAD_FORMATS.AssemblyScript) {\n      const payload = meta.coverage as AssemblyScriptCoveragePayload;\n      const { coverageData, suiteLogLabel: label } = payload;\n      suiteLogLabel = label;\n\n      debug(() => {\n        const fileCount = Object.keys(coverageData.hitCountsByFileAndPosition).length;\n        const positionCount = Object.values(coverageData.hitCountsByFileAndPosition)\n          .reduce((sum, positions) => sum + Object.keys(positions).length, 0);\n        return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun - Suite payload: ${positionCount} unique positions over ${fileCount} source files`;\n      });\n\n      // Merge incoming coverage data into accumulated (by position, summing hit counts)\n      mergeCoverageData(this.accumulatedCoverageData, coverageData);\n\n      debug(() => {\n        const fileCount = Object.keys(this.accumulatedCoverageData.hitCountsByFileAndPosition).length;\n        const positionCount = Object.values(this.accumulatedCoverageData.hitCountsByFileAndPosition)\n          .reduce((sum, positions) => sum + Object.keys(positions).length, 0);\n        return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun - Accumulated coverage: ${positionCount} unique positions over ${fileCount} source files`;\n      });\n    } else {\n      // Delegate to v8 provider for all other formats (JS, etc.)\n      if (!this.v8Provider) {\n        throw createPoolError(\n          'HybridCoverageProvider - onAfterSuiteRun failed to delegate to v8 provider',\n          POOL_ERROR_NAMES.HybridCoverageProviderError\n        );\n      }\n\n      debug(`[HybridCoverageProvider] ${suiteLogLabel} - Delegating to v8 provider`);\n      await this.v8Provider.onAfterSuiteRun(meta);\n    }\n\n    debug(() => {\n      const files = meta.testFiles.map(tf => relative(this.projectConfig.root, tf)).join(',');\n      return `[HybridCoverageProvider] ${suiteLogLabel} - onAfterSuiteRun complete - TIMING ${(performance.now() - start).toFixed(2)} ms | testFiles: \"${files}\"`;\n    });\n  }\n\n  /**\n   * Generate unified coverage map (merging JS and AS coverage)\n   *\n   * Flow:\n   * 1. Parse included AS source files to get sourceDebugInfo (source of truth for line numbers)\n   * 1. Build merged CoverageData (all source functions + accumulated hit counts)\n   * 4. Convert merged CoverageData to Istanbul format\n   * 5. Get JS coverage from v8 provider\n   * 6. Merge AS coverage into JS coverage\n   */\n  async generateCoverage(context: ReportContext): Promise<unknown> {\n    const start = performance.now();\n\n    debug('[HybridCoverageProvider] Generating coverage for test run');\n\n    if (!this.v8Provider) {\n      throw createPoolError(\n        'HybridCoverageProvider - generateCoverage failed to delegate to v8 provider',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n\n    // Build AS coverage map\n    let asCoverageMap = createCoverageMap();\n\n    if (this.coverageOptions.globbedAssemblyScriptInclude?.length > 0) {\n      debug(`[HybridCoverageProvider] Building AS coverage map with ${this.coverageOptions.globbedAssemblyScriptInclude.length} source files `);\n      debug(() => {\n        const accumulatedPositionCount = Object.values(this.accumulatedCoverageData.hitCountsByFileAndPosition)\n          .reduce((sum, positions) => sum + Object.keys(positions)?.length, 0);\n        const files = Object.keys(this.accumulatedCoverageData.hitCountsByFileAndPosition).length;\n        return `[HybridCoverageProvider] Accumulated coverage data has ${accumulatedPositionCount} unique positions hit across ${files} debug source files`;\n      });\n\n      // parse source files with AST parser, then match to hits and convert to istanbul format\n      const fileProcessingPromises = this.coverageOptions.globbedAssemblyScriptInclude.map(async (include: GlobResult) => {\n        debug(`[HybridCoverageProvider] Parsing AS source for expected coverage: \"${include.absolute}\" (file key: \"${include.projectRootRelative}\")`);\n        \n        const functionsByStartLine = await parseFunctionsFromFile(include.absolute, include.projectRootRelative) || {};\n        debug(`[HybridCoverageProvider] Parsed ${Object.keys(functionsByStartLine).length} AS source functions in \"${include.projectRootRelative}\"`);\n\n        const fileHitCountsByPosition = this.accumulatedCoverageData.hitCountsByFileAndPosition[include.projectRootRelative] ?? {};\n        debug(`[HybridCoverageProvider] Accumulated AS coverage has ${Object.keys(fileHitCountsByPosition).length} positions for \"${include.projectRootRelative}\"`);\n\n        // Containment matching (binary hit position → source) is performed during istanbul conversion\n        return convertToIstanbulFormat(functionsByStartLine, fileHitCountsByPosition, include.absolute);\n      });\n\n      // Wait for all files to complete\n      const istanbulResults = await Promise.all(fileProcessingPromises);\n\n      // Add all results to coverage map\n      for (const istanbulData of istanbulResults) {\n        asCoverageMap.addFileCoverage(istanbulData);\n      }\n\n      debug(`[HybridCoverageProvider] Built AS coverage map with ${Object.keys(asCoverageMap.data).length} files`);\n    } else {\n      debug('[HybridCoverageProvider] WARNING: No assemblyScriptInclude patterns yieldled files - Coverage Map will be empty!');\n    }\n\n    const asGenerateEnd = performance.now();\n    debug(`[HybridCoverageProvider] TIMING AS generateCoverage: ${(asGenerateEnd - start).toFixed(2)} ms`);\n\n    // Get JS coverage from v8 provider\n    debug('[HybridCoverageProvider] Getting JS coverage from v8 provider');\n    const jsCoverage = await this.v8Provider.generateCoverage(context) as CoverageMap;\n    debug(`[HybridCoverageProvider] JS coverage has ${Object.keys(jsCoverage.data).length} files`);\n    debug(`[HybridCoverageProvider] TIMING JS generateCoverage: ${(performance.now() - asGenerateEnd).toFixed(2)} ms`);\n\n    // Merge AS coverage into JS coverage\n    debug('[HybridCoverageProvider] Merging AS coverage into JS coverage');\n    jsCoverage.merge(asCoverageMap);\n    debug(`[HybridCoverageProvider] Final merged coverage has ${Object.keys(jsCoverage.data).length} files`);\n\n    debug(`[HybridCoverageProvider] TIMING Total generateCoverage: ${(performance.now() - start).toFixed(2)} ms`);\n\n    return jsCoverage;\n  }\n\n  /**\n   * Report coverage - delegate to v8 provider\n   */\n  async reportCoverage(coverageMap: unknown, context: ReportContext): Promise<void> {\n    if (!this.v8Provider) {\n      throw createPoolError(\n        'HybridCoverageProvider - reportCoverage failed to delegate to v8 provider',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n\n    debug(`[HybridCoverageProvider] Reporting coverage (allTestsRun=${context.allTestsRun})`);\n    await this.v8Provider.reportCoverage(coverageMap, context);\n  }\n\n  /**\n   * Resolve options\n   */\n  resolveOptions(): ResolvedHybridProviderOptions {\n    if (!this.v8Provider) {\n      throw createPoolError(\n        'HybridCoverageProvider - resolveOptions failed to delegate to v8 provider',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n    \n    debug(`[HybridCoverageProvider] Resolving Coverage Options`);\n  \n    const definedCoverageOptions = this.projectConfig.coverage as CustomProviderOptions;\n    const resolvedV8Options = this.v8Provider.resolveOptions() as ResolvedCoverageOptions<'v8'>;\n\n    // For some reason the v8 provider builds its `excludes` values to include a null byte.\n    // Remove null bytes for logging purposes so tools like grep won't complain about binary content.\n    const sanitizedV8Options: ResolvedCoverageOptions<'v8'> = {\n      ...resolvedV8Options,\n      include: resolvedV8Options.include?.map(i => i.replace(/\\0/g, '')) || undefined,\n      exclude: resolvedV8Options.exclude?.map(i => i.replace(/\\0/g, '')) || undefined\n    };\n\n    debug(`[HybridCoverageProvider] AS include: ${(definedCoverageOptions.assemblyScriptInclude || []).join(', ') || '(none)'}`);\n    debug(`[HybridCoverageProvider] AS exclude: ${(definedCoverageOptions.assemblyScriptExclude || []).join(', ') || '(none)'}`);\n    debug(`[HybridCoverageProvider] JS include: ${(sanitizedV8Options.include || []).join(', ') || '(none)'}`);\n    debug(`[HybridCoverageProvider] JS exclude: ${(sanitizedV8Options.exclude || []).join(', ') || '(none)'}`);\n\n    debug(`[HybridCoverageProvider] Globbing AS source files to include for coverage map basis`);\n    const globbedAssemblyScriptInclude = globFiles(\n      definedCoverageOptions.assemblyScriptInclude || [],\n      definedCoverageOptions.assemblyScriptExclude || [],\n      this.projectConfig.root\n    );\n    debug(`[HybridCoverageProvider] Including ${globbedAssemblyScriptInclude.length} AS files in coverage map`);\n    \n    const globbedAssemblyScriptExcludeOnly = globFiles(\n      definedCoverageOptions.assemblyScriptExclude || [],\n      [],\n      this.projectConfig.root\n    );\n    debug(`[HybridCoverageProvider] Excluding ${globbedAssemblyScriptExcludeOnly.length} AS files from coverage map & instrumentation`);\n    \n    const resolvedCoverageOptions: ResolvedHybridProviderOptions = {\n      ...resolvedV8Options,\n      provider: 'custom',\n      customProviderModule: definedCoverageOptions.customProviderModule,\n      assemblyScriptInclude: definedCoverageOptions.assemblyScriptInclude ?? [],\n      assemblyScriptExclude: definedCoverageOptions.assemblyScriptExclude ?? [],\n      globbedAssemblyScriptInclude,\n      globbedAssemblyScriptProjectRelativeExcludeOnly : globbedAssemblyScriptExcludeOnly.map(gr => gr.projectRootRelative)\n    }; \n\n    this.coverageOptions = resolvedCoverageOptions;\n    return resolvedCoverageOptions;\n  }\n\n  async clean(clean: boolean = true): Promise<void> {\n    debug('[HybridCoverageProvider] Clean coverage data - clean:', clean);\n    if (clean) {\n      this.accumulatedCoverageData = { hitCountsByFileAndPosition: {} };\n      debug('[HybridCoverageProvider] Cleaned all internal coverage data');\n    }\n\n    if (this.v8Provider) {\n      await this.v8Provider.clean(clean);\n      debug(`[HybridCoverageProvider] V8 provider finished clean(${clean})`);\n    }\n  }\n}\n","/**\n * Coverage Provider Module Export\n *\n * This module exports the hybrid coverage provider for Vitest to load.\n * Users configure this via:\n *   coverage.provider = 'custom'\n *   coverage.customProviderModule = 'vitest-pool-assemblyscript/coverage'\n */\n\nimport { CoverageProviderModule } from 'vitest/node';\nimport v8CoverageModule from '@vitest/coverage-v8';\n\nimport { POOL_ERROR_NAMES } from '../types/constants.js';\nimport { createPoolError } from '../util/pool-errors.js';\nimport { HybridCoverageProvider } from './hybrid-coverage-provider.js';\n\n/**\n * Hybrid Coverage Provider\n *\n * This provider handles both AssemblyScript and JavaScript and coverage\n * - Converts AS coverage to Istanbul format\n * - Delegates JS coverage to Vitest's v8 provider\n * - Merges both into a unified coverage report\n */\nconst hybridProviderModule: CoverageProviderModule = {\n  getProvider: (): HybridCoverageProvider => new HybridCoverageProvider(),\n\n  startCoverage: async (runtimeOptions: {\n    isolate: boolean\n  }): Promise<unknown> => {\n    if (v8CoverageModule.startCoverage) {\n      return await v8CoverageModule.startCoverage(runtimeOptions);\n    } else {\n      throw createPoolError(\n        'HybridCoverageProvider - v8 coverage module does not provide `startCoverage`',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n  },\n  \n  takeCoverage: async (runtimeOptions?: any): Promise<unknown> => {\n    if (v8CoverageModule.takeCoverage) {\n      return await v8CoverageModule.takeCoverage(runtimeOptions);\n    } else {\n      throw createPoolError(\n        'HybridCoverageProvider - v8 coverage module does not provide `takeCoverage`',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n  },\n  \n  stopCoverage: async (runtimeOptions: {\n    isolate: boolean\n  }): Promise<unknown> => {\n    if (v8CoverageModule.stopCoverage) {\n      return await v8CoverageModule.stopCoverage(runtimeOptions);\n    } else {\n      throw createPoolError(\n        'HybridCoverageProvider - v8 coverage module does not provide `stopCoverage`',\n        POOL_ERROR_NAMES.HybridCoverageProviderError\n      );\n    }\n  },\n};\n\nexport default hybridProviderModule;\n"],"mappings":"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"}

package/dist/custom-provider-options-CF5C1kXb.d.mts

@@ -0,0 +1,26 @@
+import { HybridProviderOptions } from "./types-8KKo9Hbf.mjs";
+import { CoverageV8Options } from "vitest/node";
+
+//#region src/config/custom-provider-options.d.ts
+/**
+* Module augmentation for CustomProviderOptions
+*
+* Vitest v3's CustomProviderOptions only includes fields with default values,
+* but users should be able to configure all optional fields from BaseCoverageOptions.
+* This augmentation adds the missing optional fields that work at runtime but
+* aren't typed in vitest v3.
+*
+* Additionally, we add AssemblyScript-specific coverage fields that our hybrid
+* coverage provider uses to glob AS source files separately from JS sources.
+*
+* By placing this augmentation here, it automatically loads when users import
+* our config helpers, providing proper coverage typing alongside pool typing.
+*/
+declare module "vitest/node" {
+  interface CustomProviderOptions extends HybridProviderOptions, Omit<CoverageV8Options, "provider"> {
+    provider: "custom";
+    /** Name of the module or path to a file to load the custom provider from */
+    customProviderModule: string;
+  }
+}
+//# sourceMappingURL=custom-provider-options-CF5C1kXb.d.mts.map

package/dist/custom-provider-options-CF5C1kXb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-provider-options-CF5C1kXb.d.mts","names":[],"sources":["../src/config/custom-provider-options.ts"],"mappings":";;;;;;AAE2C;;;;;;;;;;;;;YAiB/B,qBAAA,SAA8B,qBAAA,EAAuB,IAAA,CAAK,iBAAA;IAClE,QAAA;IAGD;IAAA,oBAAA;EAAA;AAAA"}

package/dist/debug-IeEHsxy0.mjs

@@ -0,0 +1,195 @@
+import { POOL_ERROR_NAMES, TEST_ERROR_NAMES } from "./constants-CA50WBdr.mjs";
+import { stripVTControlCharacters } from "node:util";
+import c from "tinyrainbow";
+
+//#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}`)}`);
+}
+function getSourceCodeFrameString(sourceMap, frame, highlight) {
+	if (!sourceMap.sourcesContent) return;
+	const fileIndex = sourceMap.sources.indexOf(frame.file);
+	if (fileIndex < 0) return;
+	const source = sourceMap.sourcesContent[fileIndex];
+	if (!source) return;
+	return generateCodeFrame(source.length < MAX_CODE_HIGHLIGHT_LENGTH ? highlight(source, { colors: c }) : 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/util/pool-errors.ts
+function createPoolError(message, name, stack, cause, rawCallStack) {
+	return {
+		name,
+		message,
+		stack,
+		cause,
+		rawCallStack,
+		["__as_pool__"]: true
+	};
+}
+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 assertions passed`;
+	return {
+		name: TEST_ERROR_NAMES.AssertionError,
+		message,
+		stack: `${test.id}_${message}`,
+		diff: getYellowString(` Expected to fail, but all assertions passed`)
+	};
+}
+function throwPoolErrorIfAborted(signal) {
+	if (!signal || !signal.aborted) return;
+	throw createPoolError(signal.reason, POOL_ERROR_NAMES.PoolRunAbortedError);
+}
+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 createPoolErrorFromAnyError(context, contextErrorName, error) {
+	if (isAbortErrorString(error)) return createPoolError(`${contextErrorName}: ${context} - Aborted, Unknown Cause`, POOL_ERROR_NAMES.PoolRunAbortedError);
+	if (error["__as_pool__"]) return error;
+	if (error instanceof Error) {
+		const isAbortError = isAbortErrorString(error.name);
+		return createPoolError(`${context} - ${error.name}: ${error.message}`, isAbortError ? POOL_ERROR_NAMES.PoolRunAbortedError : contextErrorName, error.stack, error.cause);
+	}
+	return createPoolError(`${context} - ${String(error)}`, contextErrorName);
+}
+function getTestErrorFromPoolError(error) {
+	const anyCause = error?.cause;
+	if (error.causeIsEnhancedError) return error.cause;
+	const message = error.message ?? anyCause.message ?? "Unknown error";
+	return {
+		name: error.name ?? anyCause.name ?? POOL_ERROR_NAMES.PoolError,
+		message,
+		stack: anyCause?.stack ?? error.stack ?? message,
+		stacks: anyCause?.stacks,
+		cause: getTestErrorFromAnyError(anyCause?.cause),
+		diff: anyCause?.diff
+	};
+}
+function getTestErrorFromAnyError(error, context = "", fallbackName = POOL_ERROR_NAMES.PoolError) {
+	if (!error) return;
+	const message = `${context ?? ""}${error?.message ?? ""}`;
+	return {
+		name: error?.name ?? fallbackName,
+		message,
+		stack: error?.stack ?? message,
+		stacks: error?.stacks,
+		cause: getTestErrorFromAnyError(error?.cause)
+	};
+}
+
+//#endregion
+//#region src/util/debug.ts
+globalThis.AS_POOL_DEBUG = false;
+const DEBUG_ENV_ENABLED_VALUE = "1";
+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;
+}
+/**
+* Log debug message (only when debug enabled in current global context)
+* or when environment has a truthy DEBUG variable set.
+*/
+function debug(...args) {
+	if (isEnabled()) 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);
+}
+/**
+* Determine if debug mode is enabled for the current global context
+*/
+function isDebugModeEnabled() {
+	return isEnabled();
+}
+
+//#endregion
+export { createPoolError, createPoolErrorFromAnyError, createTestExpectedToFailError, createTestTimeoutError, debug, getSourceCodeFrameString, getTestErrorFromPoolError, isAbortError, isDebugModeEnabled, setGlobalDebugMode, throwPoolErrorIfAborted, toPlaintextStackFrameString, toVitestLikeStackFrameString };
+//# sourceMappingURL=debug-IeEHsxy0.mjs.map

package/dist/debug-IeEHsxy0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-IeEHsxy0.mjs","names":[],"sources":["../src/util/test-error-formatting.ts","../src/util/pool-errors.ts","../src/util/debug.ts"],"sourcesContent":["import { stripVTControlCharacters } from 'node:util';\nimport type { RawSourceMap } from 'source-map';\nimport c from 'tinyrainbow';\nimport type { ParsedStack } from '@vitest/utils';\n\nimport { HighlightFunc } from '../types/types.js';\n\nconst FRAME_POINTER = '❯' as const;\nconst CODE_FRAME_INDENT_SPACES = 4 as const;\n\n// same performance guard used in vitest `printError`\nconst MAX_CODE_HIGHLIGHT_LENGTH = 100_000 as const;\n\nexport function getYellowString(str: string): string {\n  return c.yellow(str);\n}\n\nexport function toPlaintextStackFrameString(frame: ParsedStack): string {\n  return `    at ${frame.method} ${frame.file}:${frame.line}:${frame.column}`;\n}\n\nexport function toVitestLikeStackFrameString(frame: ParsedStack): string {\n  return c.cyan(\n    ` ${c.dim(FRAME_POINTER)} ${frame.method} ${frame.file}:${c.dim(`${frame.line}:${frame.column}`)}`\n  );\n}\n\nexport function getSourceCodeFrameString(\n  sourceMap: RawSourceMap,\n  frame: ParsedStack,\n  highlight: HighlightFunc,\n): string | undefined {\n  if (!sourceMap.sourcesContent) {\n    return undefined;\n  }\n\n  const fileIndex = sourceMap.sources.indexOf(frame.file);\n  if (fileIndex < 0) {\n    return undefined;\n  }\n\n  const source = sourceMap.sourcesContent[fileIndex];\n  if (!source) {\n    return undefined;\n  }\n\n  const highlightedSource = source.length < MAX_CODE_HIGHLIGHT_LENGTH\n    ? highlight(source, { colors: c })\n    : source;\n\n  return generateCodeFrame(highlightedSource, CODE_FRAME_INDENT_SPACES, frame);\n}\n\n\n// ============================================================================\n// Source code formatting functions borrowed from Vitest\n// ============================================================================\n\n/**\n * Vitest doesn't expose generateCodeFrame as a util, so we have\n * recreated it here with minimal changes.\n * \n * @see https://github.com/vitest-dev/vitest/blob/v3.2.4/packages/vitest/src/node/printError.ts#L424\n * \n * Vitest is released under the MIT license, included in this project's root.\n * Copyright (c) 2021-Present Vitest Team\n */\n\nconst lineSplitRE: RegExp = /\\r?\\n/;\n\nfunction generateCodeFrame(\n  source: string,\n  indent = 0,\n  loc: { line: number; column: number } | number,\n  range = 2,\n): string {\n  const start\n    = typeof loc === 'object'\n      ? positionToOffset(source, loc.line, loc.column)\n      : loc\n  const end = start\n  const lines = source.split(lineSplitRE)\n  const nl = /\\r\\n/.test(source) ? 2 : 1\n  let count = 0\n  let res: string[] = []\n\n  const columns = process.stdout?.columns || 80\n\n  for (let i = 0; i < lines.length; i++) {\n    count += lines[i]!.length + nl\n    if (count >= start) {\n      for (let j = i - range; j <= i + range || end > count; j++) {\n        if (j < 0 || j >= lines.length) {\n          continue\n        }\n\n        const lineLength = lines[j]!.length\n\n        // too long, maybe it's a minified file, skip for codeframe\n        if (stripVTControlCharacters(lines[j]!).length > 200) {\n          return ''\n        }\n\n        res.push(\n          lineNo(j + 1)\n          + truncateString(lines[j]!.replace(/\\t/g, ' '), columns - 5 - indent),\n        )\n\n        if (j === i) {\n          // push underline\n          const pad = start - (count - lineLength) + (nl - 1)\n          const length = Math.max(\n            1,\n            end > count ? lineLength - pad : end - start,\n          )\n          res.push(lineNo() + ' '.repeat(pad) + c.red('^'.repeat(length)))\n        }\n        else if (j > i) {\n          if (end > count) {\n            const length = Math.max(1, Math.min(end - count, lineLength))\n            res.push(lineNo() + c.red('^'.repeat(length)))\n          }\n          count += lineLength + 1\n        }\n      }\n      break\n    }\n  }\n\n  if (indent) {\n    res = res.map(line => ' '.repeat(indent) + line)\n  }\n\n  return res.join('\\n')\n}\n\n\nfunction positionToOffset(\n  source: string,\n  lineNumber: number,\n  columnNumber: number,\n): number {\n  const lines = source.split(lineSplitRE)\n  const nl = /\\r\\n/.test(source) ? 2 : 1\n  let start = 0\n\n  if (lineNumber > lines.length) {\n    return source.length\n  }\n\n  for (let i = 0; i < lineNumber - 1; i++) {\n    start += lines[i]!.length + nl\n  }\n\n  return start + columnNumber\n}\n\nfunction lineNo(no: number | string = '') {\n  return c.gray(`${String(no).padStart(3, ' ')}| `)\n}\n\nfunction truncateString(text: string, maxLength: number): string {\n  const plainText = stripVTControlCharacters(text)\n\n  if (plainText.length <= maxLength) {\n    return text\n  }\n\n  return `${plainText.slice(0, maxLength - 1)}…`\n}\n","import type { Test } from '@vitest/runner/types';\n\nimport type {\n  AssemblyScriptPoolError,\n  AssemblyScriptTestError,\n  PoolErrorName,\n  TestErrorName\n} from '../types/types.js';\nimport {\n  AS_POOL_ERROR_TYPE_FLAG,\n  POOL_ERROR_NAMES,\n  TEST_ERROR_NAMES\n} from '../types/constants.js';\nimport { getYellowString } from './test-error-formatting.js';\n\nexport function createPoolError(\n  message: string,\n  name: PoolErrorName,\n  stack?: string,\n  cause?: any,\n  rawCallStack?: NodeJS.CallSite[],\n): AssemblyScriptPoolError {\n  return { name, message, stack, cause, rawCallStack, [AS_POOL_ERROR_TYPE_FLAG]: true };\n}\n\nexport function createTestTimeoutError(\n  test: Test\n): AssemblyScriptTestError {\n  const message = `Test timed out after ${test.timeout}ms`;\n  const err: AssemblyScriptTestError = {\n    name: POOL_ERROR_NAMES.WASMExecutionTimeoutError,\n    message,\n    stack: `${test.id}_${message}`,\n    diff: getYellowString(` Test Timeout Exceeded (${test.timeout}ms)`)\n  };\n  return err;\n}\n\nexport function createTestExpectedToFailError(test: Test): AssemblyScriptTestError {\n  const message = `Test is expected to fail, but all assertions passed`;\n  const err: AssemblyScriptTestError = {\n    name: TEST_ERROR_NAMES.AssertionError,\n    message,\n    stack: `${test.id}_${message}`,\n    diff: getYellowString(` Expected to fail, but all assertions passed`)\n  };\n  return err;\n}\n\nexport function throwPoolErrorIfAborted(signal?: AbortSignal): void {\n  if (!signal || !signal.aborted) {\n    return;\n  }\n\n  throw createPoolError(signal.reason, POOL_ERROR_NAMES.PoolRunAbortedError);\n}\n\nexport function isAbortErrorString(item: any): boolean {\n  return item === POOL_ERROR_NAMES.PoolRunAbortedError || item === 'AbortError';\n}\n\nexport function isAbortError(error: any): boolean {\n  return isAbortErrorString(error) \n    || isAbortErrorString(error?.name)\n    || error?.message === 'Terminating worker thread';\n}\n\nexport function createPoolErrorFromAnyError(\n  context: string,\n  contextErrorName: PoolErrorName,\n  error: any\n): AssemblyScriptPoolError {\n  const isErrorAbortString = isAbortErrorString(error);\n  if (isErrorAbortString) {\n    const msg = `${contextErrorName}: ${context} - Aborted, Unknown Cause`;\n    return createPoolError(msg, POOL_ERROR_NAMES.PoolRunAbortedError);\n  }\n\n  if (error[AS_POOL_ERROR_TYPE_FLAG]) {\n    return error as AssemblyScriptPoolError;\n  }\n\n  if (error instanceof Error) {\n    const isAbortError = isAbortErrorString(error.name);\n    const asErr = createPoolError(\n      `${context} - ${error.name}: ${error.message}`,\n      isAbortError ? POOL_ERROR_NAMES.PoolRunAbortedError : contextErrorName,\n      error.stack,\n      error.cause\n    );\n    return asErr;\n  }\n\n  const errorMsg = String(error);\n  return createPoolError(`${context} - ${errorMsg}`, contextErrorName);\n}\n\nexport function getTestErrorFromPoolError(error: AssemblyScriptPoolError): AssemblyScriptTestError {\n  const anyCause: any = error?.cause;\n  if (error.causeIsEnhancedError) {\n    return error.cause as AssemblyScriptTestError;\n  }\n\n  const message = error.message ?? anyCause.message ?? 'Unknown error';\n  return {\n    name: error.name ?? anyCause.name ?? POOL_ERROR_NAMES.PoolError,\n    message,\n    stack: anyCause?.stack ?? error.stack ?? message,\n    stacks: anyCause?.stacks ,\n    cause: getTestErrorFromAnyError(anyCause?.cause),\n    diff: anyCause?.diff\n  };\n}\n\nexport function getTestErrorFromAnyError(\n  error: any,\n  context: string = '',\n  fallbackName: TestErrorName | PoolErrorName = POOL_ERROR_NAMES.PoolError\n): AssemblyScriptTestError | undefined {\n  if (!error) {\n    return undefined;\n  }\n\n  const message = `${context ?? ''}${error?.message ?? ''}`;\n  return {\n    name: error?.name ?? fallbackName,\n    message,\n    stack: error?.stack ?? message,\n    stacks: error?.stacks,\n    cause: getTestErrorFromAnyError(error?.cause)\n  };\n}\n","/**\n * Debug logging utility\n */\n\ndeclare global {\n  var AS_POOL_DEBUG: boolean | undefined;\n}\n\nglobalThis.AS_POOL_DEBUG = false;\n\nconst DEBUG_ENV_ENABLED_VALUE = '1' as const;\n\nfunction isEnabled(): boolean {\n  return globalThis.AS_POOL_DEBUG === true || process.env.DEBUG === DEBUG_ENV_ENABLED_VALUE;\n}\n\n/**\n * Initialize debug mode for current async context (called by worker at task start)\n * @param {boolean} debugEnabled - Enable verbose debug logging\n */\nexport function setGlobalDebugMode(debugEnabled: boolean): void {\n  globalThis.AS_POOL_DEBUG = debugEnabled;\n}\n\n/**\n * Log debug message (only when debug enabled in current global context)\n * or when environment has a truthy DEBUG variable set.\n */\nexport function debug(...args: any): void {\n  if (isEnabled()) {\n    // if first arg is a function, execute it and then print the result\n    if (args?.length > 0 && typeof args[0] === 'function') {\n      const result = args[0]();\n      const rest = args.length > 1 ? args.slice(1) : [];\n      console.log(Date.now(), String(result), ...rest);\n    } else {\n      console.log(Date.now(), ...args);\n    }\n  }\n}\n\n/**\n * Determine if debug mode is enabled for the current global context\n */\nexport function isDebugModeEnabled(): boolean {\n  return isEnabled();\n}\n\nexport async function delay(ms: number = 5000): Promise<void> {\n  return new Promise<void>((resolve, _reject) => {\n    setTimeout(resolve, ms);\n  });\n}\n"],"mappings":"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"}

package/dist/index-internal.d.mts

@@ -0,0 +1,23 @@
+import { AssemblyScriptCompilerOptions, AssemblyScriptCompilerResult, AssemblyScriptPoolOptions } from "./types-8KKo9Hbf.mjs";
+
+//#region src/compiler/index.d.ts
+/**
+* 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
+*/
+declare function compileAssemblyScript(filename: string, options: AssemblyScriptCompilerOptions, logModule: string, logLabel: string, signal?: AbortSignal): Promise<AssemblyScriptCompilerResult>;
+//#endregion
+export { type AssemblyScriptCompilerResult, type AssemblyScriptPoolOptions, compileAssemblyScript };
+//# sourceMappingURL=index-internal.d.mts.map

package/dist/index-internal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-internal.d.mts","names":[],"sources":["../src/compiler/index.ts"],"mappings":";;;;;AAkDA;;;;;;;;;;;;;;iBAAsB,qBAAA,CACpB,QAAA,UACA,OAAA,EAAS,6BAAA,EACT,SAAA,UACA,QAAA,UACA,MAAA,GAAS,WAAA,GACR,OAAA,CAAQ,4BAAA"}

package/dist/index-internal.mjs

@@ -0,0 +1,4 @@
+import "./debug-IeEHsxy0.mjs";
+import { compileAssemblyScript } from "./compiler-CN6BRK_N.mjs";
+
+export { compileAssemblyScript };

package/dist/index-v3.d.mts

@@ -0,0 +1,7 @@
+import { ProcessPool, Vitest } from "vitest/node";
+
+//#region src/pool/v3-process-pool.d.ts
+declare function createAssemblyScriptProcessPool(ctx: Vitest): ProcessPool;
+//#endregion
+export { createAssemblyScriptProcessPool as default };
+//# sourceMappingURL=index-v3.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-v3.d.mts","names":[],"sources":["../src/pool/v3-process-pool.ts"],"mappings":";;;iBA0QgB,+BAAA,CAAgC,GAAA,EAAK,MAAA,GAAS,WAAA"}

package/dist/index-v3.mjs

@@ -0,0 +1,206 @@
+import { POOL_ERROR_NAMES } from "./constants-CA50WBdr.mjs";
+import { getProjectSerializedOrGlobalConfig, resolvePoolOptions } from "./resolve-config-as1w-Qyz.mjs";
+import { createPoolErrorFromAnyError, debug, isAbortError, setGlobalDebugMode } from "./debug-IeEHsxy0.mjs";
+import { createInitialFileTask } from "./vitest-file-tasks-BUwzh375.mjs";
+import { failTestWithTimeoutError, flagTestTerminated } from "./vitest-tasks-BKS7689f.mjs";
+import { createWorkerRPCChannel } from "./worker-rpc-channel-lbhK7Qz8.mjs";
+import { basename, resolve } from "node:path";
+import { access } from "node:fs/promises";
+import Tinypool from "tinypool";
+
+//#region src/pool/v3-process-pool.ts
+/**
+* AssemblyScript Pool for Vitest
+*/
+const WORKER_PATH = resolve(import.meta.dirname, "pool-thread/v3-tinypool-thread.mjs");
+const POOL_THREAD_IDLE_TIMEOUT_MS = 36e5;
+async function dispatchFullWorkerRun(spec, config, isCollectTestsMode, pool, poolAbortSignal, fileCache, testTimeoutCache, previousTimedOutTest) {
+	const fileRunStart = Date.now();
+	const testFilePath = spec.moduleId;
+	const base = basename(testFilePath);
+	debug(`[Pool] ${base} - Starting file worker run at ${fileRunStart} for "${testFilePath}"`);
+	let fileCompilation = fileCache.get(spec.moduleId);
+	const isTimeoutRedispatch = !!previousTimedOutTest && !!fileCompilation;
+	let timedOutTestThisRun;
+	try {
+		const fileAbortController = new AbortController();
+		const file = isTimeoutRedispatch ? previousTimedOutTest.file : createInitialFileTask(spec.moduleId, spec.project.name, config.root, config.testTimeout, config.retry);
+		const { workerPort, poolPort } = createWorkerRPCChannel(spec.project, isCollectTestsMode);
+		poolPort.on("message", (event) => {
+			if (!event["__as_pool__"]) return;
+			const msg = event;
+			if (msg.type === "file-compiled") {
+				const { compilation } = msg;
+				fileCache.set(compilation.filePath, compilation);
+				debug(`[Pool] ${basename(compilation.filePath)} - Got compiled file cache for "${compilation.filePath}"`);
+			} else if (msg.type === "execution-start") {
+				const poolReceivedExecutionStart = Date.now();
+				const { executionStart, test } = msg;
+				const transitDuration = poolReceivedExecutionStart - executionStart;
+				const adjustedTimeout = Math.max(test.timeout - transitDuration, 0);
+				debug(`[Pool] ${base} - "${test.name}": Received worker execution start (transit ${transitDuration} ms) - Beginning test timeout timer ${test.timeout} ms (adjusted timeout: ${adjustedTimeout} ms)`);
+				const testTimeoutId = setTimeout(async () => {
+					const poolTimeoutTime = Date.now();
+					const record = testTimeoutCache.get(test.id);
+					testTimeoutCache.delete(test.id);
+					if (record) {
+						const elapsedFromWorkerExecutionStart = poolTimeoutTime - record.executionStart;
+						failTestWithTimeoutError(record.test, poolTimeoutTime, elapsedFromWorkerExecutionStart);
+						flagTestTerminated(record.test);
+						timedOutTestThisRun = test;
+						fileAbortController.abort(POOL_ERROR_NAMES.WASMExecutionTimeoutError);
+						debug(`[Pool] ${base} - "${record.test.name}" timed out (threshold ${record.test.timeout} ms) - Aborted worker job (duration before abort: ${elapsedFromWorkerExecutionStart} ms)`);
+					}
+				}, adjustedTimeout);
+				testTimeoutCache.set(test.id, {
+					test,
+					executionStart,
+					timeoutId: testTimeoutId
+				});
+			} else if (msg.type === "execution-end") {
+				const poolReceivedExecutionEnd = Date.now();
+				const { executionEnd, testTaskId } = msg;
+				const record = testTimeoutCache.get(testTaskId);
+				testTimeoutCache.delete(testTaskId);
+				if (record) {
+					clearTimeout(record.timeoutId);
+					const elapsedFromWorkerExecutionStart = executionEnd - record.executionStart;
+					const transitDuration = poolReceivedExecutionEnd - executionEnd;
+					debug(`[Pool] ${base} - "${record.test.name}": Received worker execution end (transit: ${transitDuration} ms) - Clearing test timeout timer - Actual duration from worker exection start: ${elapsedFromWorkerExecutionStart} ms`);
+				}
+			}
+		});
+		const workerTaskData = {
+			dispatchStart: Date.now(),
+			port: workerPort,
+			file,
+			config,
+			isCollectTestsMode,
+			timedOutTest: previousTimedOutTest,
+			timedOutCompilation: fileCompilation
+		};
+		try {
+			await pool.run(workerTaskData, {
+				name: "runTestFile",
+				transferList: [workerPort],
+				signal: AbortSignal.any([poolAbortSignal, fileAbortController.signal])
+			});
+		} finally {
+			workerPort.close();
+			poolPort.close();
+		}
+		return;
+	} catch (error) {
+		if (isAbortError(error)) {
+			debug(`[Pool] ${base} - file worker aborted during run: ${String(error)}`);
+			if (!!timedOutTestThisRun) return timedOutTestThisRun;
+			else return;
+		}
+		throw createPoolErrorFromAnyError(`${base} - unhandled file worker failure`, POOL_ERROR_NAMES.PoolError, error);
+	} finally {
+		debug(`[Pool] ${base} - Finished File Worker Execution`);
+	}
+}
+/**
+* Run / Collect tests
+*/
+async function runTests(specs, isCollectTestsMode, pool, poolAbortController, _invalidatedFiles) {
+	const mode = isCollectTestsMode ? "collectTests" : "runTests";
+	debug(`[Pool] -------- ${mode} called for ${specs.length} specs --------`);
+	const fileCache = /* @__PURE__ */ new Map();
+	const testTimeoutCache = /* @__PURE__ */ new Map();
+	const fileWorkers = specs.map(async (spec) => {
+		const { serializedConfig } = spec.project;
+		let timedOutTest = await dispatchFullWorkerRun(spec, serializedConfig, isCollectTestsMode, pool, poolAbortController.signal, fileCache, testTimeoutCache);
+		while (timedOutTest) timedOutTest = await dispatchFullWorkerRun(spec, serializedConfig, isCollectTestsMode, pool, poolAbortController.signal, fileCache, testTimeoutCache, timedOutTest);
+	});
+	if (isCollectTestsMode) try {
+		await Promise.all(fileWorkers);
+		debug("[Pool] collectTests - All file workers resolved");
+	} catch (err) {
+		debug("[Pool] collectTests - File worker REJECTED, Calling Pool Abort to bail this collectTests run");
+		poolAbortController.abort();
+	}
+	else {
+		const results = await Promise.allSettled(fileWorkers);
+		const unexpectedErrors = [];
+		results.forEach((r) => {
+			if (r.status === "rejected") unexpectedErrors.push(r.reason);
+		});
+		if (unexpectedErrors.length === 0) debug(`[Pool] ${mode} - All file workers resolved`);
+		else {
+			debug(`[Pool] ${mode} - Some file workers REJECTED unexpectedly. Throwing error(s) to vitest:`, unexpectedErrors);
+			throw {
+				name: POOL_ERROR_NAMES.PoolError,
+				message: `Unexpected AssemblyScript Pool Error(s) Encountered during ${mode}`,
+				cause: unexpectedErrors[0]
+			};
+		}
+	}
+	debug(`[Pool] Timeout Cache Size: ${testTimeoutCache.size}`);
+	testTimeoutCache.forEach((record, testId) => {
+		if (record) {
+			debug(`[Pool] Leftover timeout entry for task: ${record.test.name}`);
+			clearTimeout(record.timeoutId);
+		} else debug(`[Pool] Empty test timeout entry for task: ${testId}`);
+	});
+	debug(`[Pool] -------- ${mode} completed --------`);
+}
+function createAssemblyScriptProcessPool(ctx) {
+	const { config, foundProjectSerializedConfig } = getProjectSerializedOrGlobalConfig(ctx);
+	const poolOptions = resolvePoolOptions(config?.poolOptions);
+	setGlobalDebugMode(poolOptions.debug);
+	debug("[Pool] Initializing AssemblyScript Pool");
+	if (foundProjectSerializedConfig) debug(`[Pool] Multi-project mode: Using config from project: "${config.name}"`);
+	else debug("[Pool] Single-project mode: No project config found using vitest-pool-assemblyscript pool - Using global config with AssemblyScript pool defaults");
+	debug(`[Pool] Worker thread path: "${WORKER_PATH}"`);
+	debug(`[Pool] Worker thread configuration - maxThreads: ${poolOptions.maxThreadsV3}`);
+	setImmediate(async () => {
+		const userImportsFactoryPath = resolve(config.root, poolOptions.wasmImportsFactory ?? "");
+		const results = await Promise.allSettled([access(WORKER_PATH), poolOptions.wasmImportsFactory ? access(userImportsFactoryPath) : Promise.resolve()]);
+		if (results[0].status === "rejected") throw new Error(`Cannot access worker thread file at path: "${WORKER_PATH}"`);
+		if (results[1].status === "rejected") throw new Error(`Cannot access user WasmImportsFactory at path: "${userImportsFactoryPath}". Ensure that your module path is relative to the project root (location of shallowest vitest config), and that it has a default export matching () => WebAssembly.Imports`);
+	});
+	const pool = new Tinypool({
+		filename: WORKER_PATH,
+		minThreads: 1,
+		maxThreads: poolOptions.maxThreadsV3,
+		idleTimeout: POOL_THREAD_IDLE_TIMEOUT_MS,
+		isolateWorkers: false,
+		workerData: {
+			asPoolOptions: poolOptions,
+			asCoverageOptions: config.coverage,
+			projectRoot: config.root
+		}
+	});
+	const poolAbortController = new AbortController();
+	ctx.onCancel((reason) => {
+		const reasonMsg = reason === "test-failure" ? "Bail after test failure" : reason;
+		console.log(`${"assemblyscript"} - Aborting all tests: ${reasonMsg}`);
+		poolAbortController.abort();
+	});
+	return {
+		name: "assemblyscript",
+		async collectTests(specs) {
+			return runTests(specs, true, pool, poolAbortController);
+		},
+		async runTests(specs, invalidates) {
+			return runTests(specs, false, pool, poolAbortController, invalidates);
+		},
+		async close() {
+			debug("[Pool] AbortController called");
+			poolAbortController.abort();
+			debug("[Pool] Tinypool destroyed");
+			await pool.destroy();
+			debug("[Pool] Exiting");
+		}
+	};
+}
+
+//#endregion
+//#region src/index-v3.ts
+var index_v3_default = createAssemblyScriptProcessPool;
+
+//#endregion
+export { index_v3_default as default };
+//# sourceMappingURL=index-v3.mjs.map