vitest-pool-assemblyscript 0.8.0 → 0.9.1

package/assembly/expect.ts

@@ -2,12 +2,16 @@ import {
   closeTo,
   compareInequality,
   equals,
+  equalsPathClear,
+  equalsPathString,
+  equalsRefPairsClear,
+  equalsRtmNamesClear,
+  equalsRtmNamesSuffix,
   identical,
   InequalityOperation,
-  isNull,
-  nan,
-  truthyOrFalsey
+  truthyOrFalsey,
 } from './compare';
+import { isNull, nan, stringifyValue } from './utils';
 
 // @external functions are imported to the WASM execution environment from pool code
 
@@ -34,43 +38,6 @@ declare function __expect_throw(fnPtr: usize, errorMsg?: string): void;
 declare function __end_expect_throw(): void;
 
 
-function itemMessageString<T>(item: T): string {
-  if (isNull(item)) return "null";
-  if (nan(item)) return "NaN";
-
-  if (isReference<T>()) {
-    if (isString<T>()) return `"${item}"`;
-    else if (item instanceof ArrayBuffer) return `ArrayBuffer[${item.byteLength}]`;
-    else if (isArrayLike<T>(item)) return arrayMessageString(item);
-    else if (item instanceof Set || item instanceof Map) return item.toString();
-    else return nameof<T>(item);
-  } else if (isBoolean<T>()){
-    return bool(item).toString();
-  } else if (isInteger<T>(item) || isFloat<T>(item)) {
-    return item.toString();
-  } else {
-    return nameof<T>(item);
-  }
-}
-
-function arrayMessageString<T extends ArrayLike<unknown>>(array: T): string {
-  if (isNullable<T>(array) && array == null) {
-    return "null";
-  }
-
-  let str = "[";
-  for (let i = 0; i < array.length; i++) {
-    str += itemMessageString(array[i]);
-
-    if (i < array.length - 1) {
-      str += ","
-    }
-  }
-  str += "]";
-
-  return str;
-}
-
 /**
  * Expect matcher
 */
@@ -106,6 +73,8 @@ abstract class BaseExpectMatcher<T> {
    *
    * @throws When comparing float/integer types where the float's mantissa cannot losslessly
    * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing fundamentally incompatible types: reference vs value type
+   * (e.g. `string` vs `i32`, unless one is null/zero), or `v128` vs non-vector type.
    *
    * @example
    * expect(1 + 1).toBe(2);
@@ -270,24 +239,47 @@ abstract class BaseExpectMatcher<T> {
 
   /**
    * Checks that two values have the same value (deep equality). Primitives and strings
-   * are compared by value. The following reference types are compared with deep equality:
-   * - `Array`: element-by-element using `toEqual()` recursively
-   * - `ArrayBuffer`: byte-level content comparison
-   * - `Set`: membership equality (same elements, order-independent)
-   * - `Map`: key-by-key with values compared using `toEqual()`
-   *
-   * Other object references use `toBe()` rules (reference identity).
-   * ⚠️ IMPORTANT: Does not yet support user-defined object deep equality checking.
-   *
+   * are compared by value, and object references are tested for deep equality.
+   * 
    * Like `toBe`, cross-type numeric comparisons follow AssemblyScript's own `==` operator
    * restrictions. `toBeCloseTo()` is safer for any comparison involving a float and
    * accurately handles precision-loss edge cases.
    * 
+   * Built-in object references are compared with the following deep equality rules:
+   * - `Array`, `StaticArray`, `TypedArray`: element-by-element comparison using `toEqual()` recursively
+   * - `Set`: deep element equality (same elements, order-independent) using `toEqual()`
+   * - `Map`: key-by-key comparison using `toEqual()` on values. Key types must match
+   *   exactly; value types support cross-type comparison
+   * - `ArrayBuffer`: byte-level content comparison
+   *
+   * Arrays, Sets, and Maps support cross-type comparison where element/value types are
+   * compatible (e.g. `Array<i32>` vs `Array<f64>`, `Map<string, i32>` vs `Map<string, f64>`).
+   * For Maps, key types must match exactly - only value types can differ.
+   *
+   * User object references of the same runtime type are compared using a deep field-by-field
+   * comparison of all stored instance fields using `toEqual()` recursively.
+   * - Includes public, protected, and private fields
+   * - Getters are **excluded**
+   * - User-defined `@operator("==")` or `.equals()` methods are used if present, instead 
+   *   of field-by-field comparison
+   * - Supports inheritance, generics, and nullable fields
+   * - Objects with different runtime types are not equal even when they share 
+   *   the same fields & values, making behavior the same as `toStrictEqual` in the
+   *   AssemblyScript pool. This differs from vitest's JavaScript `toEqual()`, 
+   *   which compares structurally regardless of constructor / runtime type
+   * - Note: If a user class extends a library class (from `node_modules` or AS stdlib),
+   *   only the user class's own declared fields are compared. Inherited library fields
+   *   are not included, as deep equality injection is scoped to user source files only
+   *
    * SIMD vectors use WASM's native `==` comparison, which compares at the bit level, 
    * ignoring lane type. 
    *
    * @throws When comparing float/integer types where the float's mantissa cannot losslessly
    * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing fundamentally incompatible types: reference vs value type
+   * (e.g. `string` vs `i32`, unless one is null/zero), or `v128` vs non-vector type.
+   * @throws When comparing containers with incompatible element types (e.g. `Array<string>`
+   * vs `Array<i32>`), or precision-loss numeric combinations (e.g. `Array<f32>` vs `Array<i32>`).
    *
    * @example
    * expect([1, 2, 3]).toEqual([1, 2, 3]);
@@ -303,23 +295,62 @@ abstract class BaseExpectMatcher<T> {
    * // SIMD vectors: different lane types with the same underlying bits are equal
    * expect(i64x2(3, 7)).toEqual(i32x4(3, 0, 7, 0));
    *
-   * // user-defined objects use reference equality (deep equality not yet supported)
-   * const x = new MyObject(1);
-   * const y = new MyObject(1);  // same data, different reference
-   * // expect(x).toEqual(y);  // throws — not yet supported
+   * // user-defined objects: deep equality
+   * const p1 = new Point(1, 2);
+   * const p2 = new Point(1, 2);
+   * expect(p1).toEqual(p2);
    */
   toEqual<U>(val: U): void {
-    this.assertComparison(equals(this.actual, val), this.actual, val, "to deeply equal", true);
+    equalsRefPairsClear();
+    equalsPathClear();
+    equalsRtmNamesClear();
+    const result = equals(this.actual, val);
+    const path = equalsPathString();
+    const isRtm = result == __vitest_assemblyscript_EqualityResult.RuntimeTypeMismatch;
+
+    let suffix = "";
+    if (isRtm) {
+      const rtmNames = equalsRtmNamesSuffix();
+      suffix = path != "" ? " (runtime type mismatch at " + path + rtmNames + ")" : " (runtime type mismatch" + rtmNames + ")";
+    } else if (path != "") {
+      suffix = " (differs at " + path + ")";
+    }
+
+    this.assertComparison(result == __vitest_assemblyscript_EqualityResult.Equal, this.actual, val, "to deeply equal", true, true, suffix, isRtm);
   }
   
   /**
-   * Alias for `toEqual`. Currently no differences in AssemblyScript.
+   * Alias for `toEqual`, no functional difference.
+   * 
+   * In JavaScript, `toEqual` compares structurally regardless of type,
+   * while `toStrictEqual` requires the same runtime type.
+   * 
+   * In AssemblyScript, `toEqual` already requires matching runtime types, 
+   * which is consistent with how most testing frameworks behave for statically-typed 
+   * languages without runtime reflection.
    *
    * @example
-   * expect([1, 2]).toStrictEqual([1, 2]);
+   * const p1 = new Point(1, 2);
+   * const p2 = new Point(1, 2);
+   * expect(p1).toEqual(p2);
    */
   toStrictEqual<U>(val: U): void {
-    this.assertComparison(equals(this.actual, val), this.actual, val, "to strictly equal", true);
+    equalsRefPairsClear();
+    equalsPathClear();
+    equalsRtmNamesClear();
+    const result = equals(this.actual, val);
+    const path = equalsPathString();
+    const isRtm = result == __vitest_assemblyscript_EqualityResult.RuntimeTypeMismatch;
+
+    let suffix = "";
+    if (isRtm) {
+      const rtmNames = equalsRtmNamesSuffix();
+      suffix = path != "" ? " (runtime type mismatch at " + path + rtmNames + ")" : " (runtime type mismatch" + rtmNames + ")";
+    } else if (path != "") {
+      suffix = " (differs at " + path + ")";
+    }
+
+    this.assertComparison(result == __vitest_assemblyscript_EqualityResult.Equal, this.actual, val, "to strictly equal", true, true, suffix, isRtm);
   }
 
   /**
@@ -382,7 +413,7 @@ abstract class BaseExpectMatcher<T> {
 
   /**
    * Checks that the type of the value is nullable (can hold `null`). This is a type-level
-   * check, not a value check — a bare `null` (which is `usize(0)`) is not itself a nullable type.
+   * check, not a value check - a bare `null` (which is `usize(0)`) is not itself a nullable type.
    * Use `toBeNull()` to check if a value is null.
    *
    * @example
@@ -448,16 +479,36 @@ abstract class BaseExpectMatcher<T> {
     }
   }
 
-  protected assertComparison<U, V>(rawCondition: bool, actual: U, expected: V, methodStr: string, printExpected: bool, provideDiff: bool = true): void {
+  protected assertComparison<U, V>(rawCondition: bool, actual: U, expected: V, methodStr: string, printExpected: bool, provideDiff: bool = true, suffix: string = "", isRtm: bool = false): void {
     const condition = this.isInverted ? !rawCondition : rawCondition;
 
     if (condition) {
       __assertion_pass();
     } else {
       const notStr = this.isInverted ? "not " : "";
-      const actualStr = itemMessageString(actual);
-      const expectedStr = itemMessageString(expected);
-      const msg = `expected ${actualStr} ${notStr}${methodStr}${printExpected ? ` ${expectedStr}` : ""}`;
+      // For runtime type mismatches, show the top-level type name only — the mismatched
+      // types in the suffix are the useful information, not field contents of differently-typed
+      // objects. Uses __vitest_assemblyscript_typename (virtual dispatch gives runtime name)
+      // with nameof fallback for types without injection (containers, primitives).
+      // For value mismatches, full stringification shows what values differ.
+      let actualStr: string;
+      let expectedStr: string;
+      if (isRtm) {
+        // @ts-ignore
+        actualStr = isDefined(actual.__vitest_assemblyscript_typename)
+          // @ts-ignore
+          ? (<NonNullable<U>>actual).__vitest_assemblyscript_typename()
+          : nameof<U>();
+        // @ts-ignore
+        expectedStr = isDefined(expected.__vitest_assemblyscript_typename)
+          // @ts-ignore
+          ? (<NonNullable<V>>expected).__vitest_assemblyscript_typename()
+          : nameof<V>();
+      } else {
+        actualStr = stringifyValue(actual);
+        expectedStr = stringifyValue(expected);
+      }
+      const msg = `expected ${actualStr} ${notStr}${methodStr}${printExpected ? ` ${expectedStr}` : ""}${suffix}`;
 
       __assertion_fail<string>(msg, nameof<U>() + " " + nameof<V>(), provideDiff, actualStr, expectedStr);
   

package/assembly/index.ts

@@ -1,13 +1,3 @@
-/**
- * Test framework with per-test crash isolation support
- *
- * Execution flow:
- * 1. Instantiation: Pool creates WASM instance with import callbacks
- * 2. Registration: _start() runs, top-level test() calls invoke __register_test callback
- * 3. Discovery: Pool receives test names + function indices via callbacks
- * 4. Execution: Pool calls table.get(fnIndex)() directly via exported function table
- */
-
 export * from './describe';
 export * from './expect';
 export * from './options';

package/assembly/utils.ts

@@ -0,0 +1,168 @@
+export function isNull<T>(value: T): bool {
+  if (isReference<T>()) {
+    if (isNullable<T>()) {
+      return value == null;
+    } else {
+      return false;
+    }
+  } else {
+    if (isBoolean<T>()) {
+      return false;
+    } else if (isVector<T>()) {
+      return false;
+    } else {
+      return nameof<T>(value) == 'usize' && value == 0;
+    }
+  }
+}
+
+export function nan<T>(value: T): bool {
+  if (isFloat<T>()) {
+    // @ts-ignore
+    return isNaN<T>(value);
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Cycle detection for stringification. Tracks which object pointers are currently
+ * being stringified to prevent infinite recursion on self-referential objects.
+ *
+ * Uses add-on-entry/remove-on-exit discipline (unlike equalsRefPairs which is add-only).
+ * This is necessary because stringifyValue is called twice per assertion (once for actual,
+ * once for expected) — the same pointer appearing in both calls is not a cycle. Add/remove
+ * ensures the set is naturally empty between calls with no external clearing needed.
+ */
+const stringifyVisited = new Set<usize>();
+
+/**
+ * Produces a human-readable string representation of a value for assertion messages.
+ * Handles primitives, strings, arrays, Sets, Maps, ArrayBuffers, and user-defined objects.
+ * Used by matchers to format actual/expected values in error output and diffs.
+ */
+export function stringifyValue<T>(item: T): string {
+  if (isNull(item)) return "null";
+  if (nan(item)) return "NaN";
+
+  if (isReference<T>()) {
+    if (isString<T>()) return `"${item}"`;
+
+    // Cycle detection for all non-string reference types before recursive stringification
+    const ptr = changetype<usize>(item);
+    if (stringifyVisited.has(ptr)) return "[Circular]";
+    stringifyVisited.add(ptr);
+
+    let result: string;
+    if (item instanceof ArrayBuffer) {
+      result = `ArrayBuffer[${item.byteLength}]`;
+    } else if (isArrayLike<T>(item)) {
+      result = arrayMessageString(item);
+    } else if (item instanceof Set) {
+      result = setMessageString(item);
+    } else if (item instanceof Map) {
+      result = mapMessageString(item);
+    // @ts-ignore: __vitest_assemblyscript_typename is injected by the compiler transform
+    } else if (isDefined(item.__vitest_assemblyscript_typename)) {
+      // Cast to NonNullable<T> because AS doesn't narrow nullability from the earlier
+      // null check — it requires explicit type narrowing to call methods on nullable types.
+      // Safe because null case returns "null" at the top of this function.
+      const nonNullItem = <NonNullable<T>>item;
+      // @ts-ignore
+      const typeName: string = nonNullItem.__vitest_assemblyscript_typename();
+      // @ts-ignore
+      if (isDefined(nonNullItem.__vitest_assemblyscript_stringify)) {
+        // @ts-ignore
+        const fields: string = nonNullItem.__vitest_assemblyscript_stringify();
+        result = fields != "" ? typeName + " { " + fields + " }" : typeName;
+      } else {
+        result = typeName;
+      }
+    } else {
+      result = nameof<T>(item);
+    }
+
+    stringifyVisited.delete(ptr);
+    return result;
+  } else if (isBoolean<T>()){
+    return bool(item).toString();
+  } else if (isInteger<T>(item) || isFloat<T>(item)) {
+    return item.toString();
+  } else {
+    return nameof<T>(item);
+  }
+}
+
+/**
+ * Global bridge for the compiler transform's injected stringify methods.
+ *
+ * Transform-injected __vitest_assemblyscript_stringify methods call this to format each
+ * field value. Declared global to make it available in all source files without import,
+ * solving the afterParse import resolution limitation.
+ *
+ * Loaded into the compilation transitively: user test imports
+ * vitest-pool-assemblyscript/assembly → index.ts → expect.ts → compare.ts → utils.ts.
+ */
+// @ts-ignore: AS-specific global decorator
+@global
+function __vitest_assemblyscript_stringify_value<T>(item: T): string {
+  return stringifyValue<T>(item);
+}
+
+function arrayMessageString<T extends ArrayLike<unknown>>(array: T): string {
+  if (isNullable<T>(array) && array == null) {
+    return "null";
+  }
+
+  let str = "[";
+  for (let i = 0; i < array.length; i++) {
+    str += stringifyValue(array[i]);
+
+    if (i < array.length - 1) {
+      str += ","
+    }
+  }
+  str += "]";
+
+  return str;
+}
+
+function setMessageString<T>(set: T): string {
+  if (isNullable<T>(set) && set == null) {
+    return "null";
+  }
+
+  if (set instanceof Set) {
+    const values = set.values();
+    let str = "Set {";
+    for (let i = 0; i < values.length; i++) {
+      if (i > 0) str += ",";
+      str += " " + stringifyValue(values[i]);
+    }
+    if (values.length > 0) str += " ";
+    str += "}";
+    return str;
+  }
+
+  return nameof<T>(set);
+}
+
+function mapMessageString<T>(map: T): string {
+  if (isNullable<T>(map) && map == null) {
+    return "null";
+  }
+
+  if (map instanceof Map) {
+    const keys = map.keys();
+    let str = "Map {";
+    for (let i = 0; i < keys.length; i++) {
+      if (i > 0) str += ",";
+      str += " " + stringifyValue(keys[i]) + " => " + stringifyValue(map.get(keys[i]));
+    }
+    if (keys.length > 0) str += " ";
+    str += "}";
+    return str;
+  }
+
+  return nameof<T>(map);
+}

package/binding.gyp

@@ -27,7 +27,7 @@
             "-lpthread"
           ],
           # Enable C++ exceptions (node-gyp disables them by default)
-          "cflags_cc": ["-std=c++17", "-fexceptions", "-O3"],
+          "cflags_cc": ["-std=c++20", "-fexceptions", "-O3"],
           "cflags!": ["-fno-exceptions"],
           "cflags_cc!": ["-fno-exceptions"]
         }],
@@ -38,9 +38,9 @@
           "xcode_settings": {
             "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
             "CLANG_CXX_LIBRARY": "libc++",
-            # Minimum macOS deployment target for C++17 support
+            # Minimum macOS deployment target for C++20 support
             "MACOSX_DEPLOYMENT_TARGET": "10.15",
-            "OTHER_CPLUSPLUSFLAGS": ["-std=c++17", "-fexceptions", "-O3"]
+            "OTHER_CPLUSPLUSFLAGS": ["-std=c++20", "-fexceptions", "-O3"]
           }
         }],
         ["OS=='win'", {
@@ -52,7 +52,7 @@
             "VCCLCompilerTool": {
               # Enable C++ exception handling (/EHsc)
               "ExceptionHandling": 1,
-              "AdditionalOptions": ["/std:c++17", "/permissive"]
+              "AdditionalOptions": ["/std:c++20", "/permissive"]
             }
           }
         }]

package/dist/{addon-interface-_pNXcbib.mjs → addon-interface-CYFXMbK7.mjs}

@@ -1,5 +1,5 @@
-import { INTERNAL_PATH_LIB_PREFIX, POOL_ERROR_NAMES } from "./constants-DuBLuMjt.mjs";
-import { createPoolError, debug } from "./debug-Cm1VFmaz.mjs";
+import { INTERNAL_PATH_LIB_PREFIX, POOL_ERROR_NAMES } from "./constants-DbxJ3hzg.mjs";
+import { createPoolError, debug } from "./debug-DtRAL4rM.mjs";
 import { toForwardSlash } from "./path-utils-t9OzjXYF.mjs";
 import { getShortFunctionName } from "./wasm-names-BFtzQCH4.mjs";
 import { createRequire } from "node:module";
@@ -184,6 +184,7 @@ const instrumentForCoverage = (wasmBuffer, sourceMapBuffer, instrumentationOptio
 		excludedFiles: instrumentationOptions.relativeExcludedFiles,
 		excludedLibraryFilePrefix: instrumentationOptions.excludedLibraryFilePrefix,
 		excludedLibraryFileOverridePrefix: instrumentationOptions.excludedLibraryFileOverridePrefix,
+		excludedInternalFunctionSubstring: instrumentationOptions.excludedInternalFunctionSubstring,
 		debug: instrumentationOptions.debug,
 		logPrefix: nativeLogPrefix
 	};
@@ -203,4 +204,4 @@ const instrumentForCoverage = (wasmBuffer, sourceMapBuffer, instrumentationOptio
 
 //#endregion
 export { instrumentForCoverage };
-//# sourceMappingURL=addon-interface-_pNXcbib.mjs.map
+//# sourceMappingURL=addon-interface-CYFXMbK7.mjs.map

package/dist/addon-interface-CYFXMbK7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon-interface-CYFXMbK7.mjs","names":[],"sources":["../src/instrumentation/addon-interface.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';\n\nimport type {\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  InstrumentForCoverageFunc,\n} from '../types/types.js';\nimport {\n  POOL_ERROR_NAMES,\n  INTERNAL_PATH_LIB_PREFIX,\n} from '../types/constants.js';\nimport { debug } from '../util/debug.js';\nimport { toForwardSlash } from '../util/path-utils.js';\nimport { createPoolError } from '../util/pool-errors.js';\nimport { getShortFunctionName } from '../wasm-executor/wasm-names.js';\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.\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\nconst rootFromDist = resolve(__dirname, '..');\n// TODO: Verify if this src fallback is still needed — pool always runs from dist/ even locally.\n// If confirmed dead code, remove this and simplify to a single nodeGypBuild call.\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      `vitest-pool-assemblyscript native instrumentation addon not found. Searched from ${rootFromDist} and ${rootFromSrc}. `\n      + `Ensure prebuilds are available or run 'node node_modules/vitest-pool-assemblyscript/scripts/install-native-addon.js'`\n      + ` to compile from source. 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, absolute path strings)\n *\n * Source map paths vary by import style and project structure:\n * - Relative imports: \"assembly/compare.ts\"\n * - Bare package imports: \"~lib/vitest-pool-assemblyscript/assembly/compare.ts\"\n * - Source outside project root: \"../assembly/compare.ts\" (e.g. test-external importing parent sources)\n *\n * All are normalized to absolute filesystem paths for consistent coverage key matching.\n */\nfunction convertLocation(\n  rawLocation: NativeSourceLocation,\n  debugSourceFiles: string[],\n  projectRoot: string\n): SourceLocation {\n  let 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  // Normalize to absolute path for consistent coverage key matching\n  if (filePath.startsWith(INTERNAL_PATH_LIB_PREFIX)) {\n    // ~lib/vitest-pool-assemblyscript/assembly/X.ts -> projectRoot/assembly/X.ts\n    const relativePart = filePath.slice(INTERNAL_PATH_LIB_PREFIX.length);\n    filePath = toForwardSlash(resolve(projectRoot, 'assembly', relativePart));\n  } else {\n    // Resolve relative path (handles both 'assembly/X.ts' and '../assembly/X.ts')\n    filePath = toForwardSlash(resolve(projectRoot, filePath));\n  }\n\n  return {\n    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  projectRoot: 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, projectRoot);\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  projectRoot: string\n): { func: FunctionDebugInfo; filePath: string; positionKey: string } | undefined {\n  const representativeLocation = convertLocation(rawFunc.representativeLocation, debugSourceFiles, projectRoot);\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, projectRoot));\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 * Check if two WASM function names are monomorphizations of the same generic function.\n * Generic monomorphizations share the same base name and suffix, differing only in\n * the type parameters inside angle brackets.\n *\n * e.g. \"assembly/compare/closeTo<bool\\2cbool>\" and \"assembly/compare/closeTo<bool\\2cu8>\"\n * e.g. \"assembly/expect/BaseExpectMatcher<bool>#constructor\" and \"assembly/expect/BaseExpectMatcher<i8>#constructor\"\n */\nfunction isGenericMonomorphizationMatch(nameA: string, nameB: string): boolean {\n  const openA = nameA.indexOf('<');\n  const openB = nameB.indexOf('<');\n\n  // Both must contain generic type parameters\n  if (openA === -1 || openB === -1) return false;\n\n  const lastCloseA = nameA.lastIndexOf('>');\n  const lastCloseB = nameB.lastIndexOf('>');\n\n  if (lastCloseA === -1 || lastCloseB === -1) return false;\n\n  // Prefix before '<' must match (includes module path, class, function name)\n  const prefixA = nameA.substring(0, openA);\n  const prefixB = nameB.substring(0, openB);\n  if (prefixA !== prefixB) return false;\n\n  // Suffix after last '>' must match (e.g. \"#constructor\", or empty)\n  const suffixA = nameA.substring(lastCloseA + 1);\n  const suffixB = nameB.substring(lastCloseB + 1);\n  if (suffixA !== suffixB) return false;\n\n  return true;\n}\n\n/**\n * Transform raw native addon output to processed BinaryDebugInfo\n */\nfunction transformDebugInfo(\n  raw: NativeDebugInfoOutput,\n  logPrefix: string,\n  projectRoot: string,\n): BinaryDebugInfo {\n  const functionsByFileAndPosition: Record<string, Record<string, FunctionDebugInfo[]>> = {};\n\n  debug(`${logPrefix} - Converting ${raw.functions.length} functions`);\n\n  let genericCollisionCount = 0;\n  let skippedCount = 0;\n  let instrumentedFunctionCount = 0;\n\n  for (const rawFunc of raw.functions) {\n    const result = convertFunction(rawFunc, raw.debugSourceFiles, projectRoot);\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    const existingAtPosition = functionsByFileAndPosition[filePath]?.[positionKey];\n    if (existingAtPosition) {\n      const existingName = existingAtPosition[0]!.name;\n\n      // Only allow collision if both are monomorphizations of the same generic\n      if (isGenericMonomorphizationMatch(existingName, func.name)) {\n        existingAtPosition.push(func);\n        genericCollisionCount++;\n        instrumentedFunctionCount++;\n        debug(\n          `${logPrefix} - Generic monomorphization at ${filePath}:${positionKey}:`\n          + ` \"${getShortFunctionName(func.name)}\" grouped with \"${getShortFunctionName(existingName)}\"`\n        );\n        continue;\n      }\n\n      throw createPoolError(\n        `ERROR - Function Debug Position Collision at ${filePath}:${positionKey}: \"${getShortFunctionName(existingName)}\"`\n        + ` will be replaced by \"${getShortFunctionName(func.name)}\". This is a bug. Please report it at:`\n        + ` https://github.com/themattspiral/vitest-pool-assemblyscript/issues/new`,\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    + ` (${genericCollisionCount} generic 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 const instrumentForCoverage: InstrumentForCoverageFunc = (\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    excludedLibraryFileOverridePrefix: instrumentationOptions.excludedLibraryFileOverridePrefix,\n    excludedInternalFunctionSubstring: instrumentationOptions.excludedInternalFunctionSubstring,\n    debug: instrumentationOptions.debug,\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, instrumentationOptions.projectRoot);\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"],"mappings":"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"}

package/dist/{ast-visitor-C5gQqWD2.mjs → ast-visitor-CWEOd3UH.mjs}

@@ -1,4 +1,4 @@
-import { ASNodeKind } from "./constants-DuBLuMjt.mjs";
+import { ASNodeKind } from "./constants-DbxJ3hzg.mjs";
 
 //#region src/util/ast-visitor.ts
 /**
@@ -10,6 +10,7 @@ import { ASNodeKind } from "./constants-DuBLuMjt.mjs";
 * - onMethodDeclaration: Called when visiting a method declaration
 * - onVariableDeclaration: Called when visiting a variable declaration
 * - onClassEnter/onClassExit: Called when entering/exiting a class
+* - onNamespaceEnter/onNamespaceExit: Called when entering/exiting a namespace
 */
 var ASTVisitor = class {
 	/**
@@ -24,6 +25,16 @@ var ASTVisitor = class {
 	*/
 	beforeVisit(_node) {}
 	/**
+	* Hook called when entering a namespace declaration.
+	* Override to track namespace context.
+	*/
+	onNamespaceEnter(_node) {}
+	/**
+	* Hook called when exiting a namespace declaration.
+	* Override to restore namespace context.
+	*/
+	onNamespaceExit(_node) {}
+	/**
 	* Hook called when entering a class declaration.
 	* Override to track class context.
 	*/
@@ -289,7 +300,9 @@ var ASTVisitor = class {
 			}
 			case ASNodeKind.NamespaceDeclaration: {
 				const decl = node;
+				this.onNamespaceEnter(decl);
 				for (const member of decl.members) this.visitNode(member);
+				this.onNamespaceExit(decl);
 				break;
 			}
 			case ASNodeKind.VariableDeclaration: {
@@ -307,4 +320,4 @@ var ASTVisitor = class {
 
 //#endregion
 export { ASTVisitor };
-//# sourceMappingURL=ast-visitor-C5gQqWD2.mjs.map
+//# sourceMappingURL=ast-visitor-CWEOd3UH.mjs.map

package/dist/ast-visitor-CWEOd3UH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-visitor-CWEOd3UH.mjs","names":[],"sources":["../src/util/ast-visitor.ts"],"sourcesContent":["/**\n * Base AST Visitor for AssemblyScript\n *\n * Provides reusable walking logic for traversing AS AST nodes.\n * Subclasses override hook methods to perform specific tasks.\n *\n * Used by:\n * - ast-parser.ts: Extract function metadata for coverage\n * - strip-inline.mts: Strip @inline decorators\n */\n\nimport {\n  Node,\n  Source,\n  BlockStatement,\n  FunctionDeclaration,\n  MethodDeclaration,\n  ClassDeclaration,\n  NamespaceDeclaration,\n  VariableStatement,\n  VariableDeclaration,\n  FunctionExpression,\n  ExpressionStatement,\n  BinaryExpression,\n  PropertyAccessExpression,\n  IfStatement,\n  WhileStatement,\n  DoStatement,\n  ForStatement,\n  ForOfStatement,\n  SwitchStatement,\n  SwitchCase,\n  TryStatement,\n  ThrowStatement,\n  ReturnStatement,\n  CallExpression,\n  NewExpression,\n  ParenthesizedExpression,\n  TernaryExpression,\n  CommaExpression,\n  AssertionExpression,\n  InstanceOfExpression,\n  ElementAccessExpression,\n  UnaryPostfixExpression,\n  UnaryPrefixExpression,\n  ClassExpression,\n  ParameterNode,\n  EnumDeclaration,\n  EnumValueDeclaration,\n  FieldDeclaration,\n  InterfaceDeclaration,\n  VoidStatement,\n} from 'assemblyscript';\n\nimport { ASNodeKind } from '../types/constants.js';\n\n/**\n * Abstract base class for AST visitors.\n *\n * Subclasses override hook methods to perform tasks during traversal:\n * - beforeVisit: Called before visiting each node (e.g., strip decorators)\n * - onFunctionDeclaration: Called when visiting a function declaration\n * - onMethodDeclaration: Called when visiting a method declaration\n * - onVariableDeclaration: Called when visiting a variable declaration\n * - onClassEnter/onClassExit: Called when entering/exiting a class\n * - onNamespaceEnter/onNamespaceExit: Called when entering/exiting a namespace\n */\nexport abstract class ASTVisitor {\n  /**\n   * Visit all statements in a source file\n   */\n  visitSource(source: Source): void {\n    for (const stmt of source.statements) {\n      this.visitNode(stmt);\n    }\n  }\n\n  /**\n   * Hook called before visiting each node.\n   * Override to perform pre-visit tasks (e.g., stripping decorators).\n   */\n  protected beforeVisit(_node: Node): void {}\n\n  /**\n   * Hook called when entering a namespace declaration.\n   * Override to track namespace context.\n   */\n  protected onNamespaceEnter(_node: NamespaceDeclaration): void {}\n\n  /**\n   * Hook called when exiting a namespace declaration.\n   * Override to restore namespace context.\n   */\n  protected onNamespaceExit(_node: NamespaceDeclaration): void {}\n\n  /**\n   * Hook called when entering a class declaration.\n   * Override to track class context.\n   */\n  protected onClassEnter(_node: ClassDeclaration): void {}\n\n  /**\n   * Hook called when exiting a class declaration.\n   * Override to restore class context.\n   */\n  protected onClassExit(_node: ClassDeclaration): void {}\n\n  /**\n   * Hook called when visiting a function declaration.\n   * Override to extract function info or perform other tasks.\n   * Return false to skip recursing into the function body.\n   */\n  protected onFunctionDeclaration(_node: FunctionDeclaration): boolean {\n    return true; // Continue recursion by default\n  }\n\n  /**\n   * Hook called when visiting a method declaration.\n   * Override to extract method info or perform other tasks.\n   * Return false to skip recursing into the method body.\n   */\n  protected onMethodDeclaration(_node: MethodDeclaration): boolean {\n    return true; // Continue recursion by default\n  }\n\n  /**\n   * Hook called when visiting a variable declaration.\n   * Override to handle variable declarations (e.g., arrow functions).\n   * Return false to skip recursing into the initializer.\n   */\n  protected onVariableDeclaration(_node: VariableDeclaration): boolean {\n    return true; // Continue recursion by default\n  }\n\n  /**\n   * Main visitor dispatch - routes to specific handler based on node kind\n   */\n  visitNode(node: Node): void {\n    // Call pre-visit hook\n    this.beforeVisit(node);\n\n    // Recurse into children based on node kind\n    switch (node.kind) {\n      // Type nodes - no children to visit\n      case ASNodeKind.NamedType:\n      case ASNodeKind.FunctionType:\n      case ASNodeKind.TypeName:\n      case ASNodeKind.TypeParameter:\n        break;\n\n      // Parameter - may have default value\n      case ASNodeKind.Parameter: {\n        const param = node as ParameterNode;\n        if (param.initializer) this.visitNode(param.initializer);\n        break;\n      }\n\n      // Simple expressions - no children\n      case ASNodeKind.Identifier:\n      case ASNodeKind.False:\n      case ASNodeKind.Literal:\n      case ASNodeKind.Null:\n      case ASNodeKind.Omitted:\n      case ASNodeKind.Super:\n      case ASNodeKind.This:\n      case ASNodeKind.True:\n      case ASNodeKind.Constructor:\n      case ASNodeKind.Compiled:\n        break;\n\n      // Expressions with children\n      case ASNodeKind.Assertion: {\n        const expr = node as AssertionExpression;\n        this.visitNode(expr.expression);\n        break;\n      }\n      case ASNodeKind.Binary: {\n        const expr = node as BinaryExpression;\n        this.visitNode(expr.left);\n        this.visitNode(expr.right);\n        break;\n      }\n      case ASNodeKind.Call: {\n        const expr = node as CallExpression;\n        this.visitNode(expr.expression);\n        for (const arg of expr.args) this.visitNode(arg);\n        break;\n      }\n      case ASNodeKind.Class: {\n        const expr = node as ClassExpression;\n        this.visitNode(expr.declaration);\n        break;\n      }\n      case ASNodeKind.Comma: {\n        const expr = node as CommaExpression;\n        for (const e of expr.expressions) this.visitNode(e);\n        break;\n      }\n      case ASNodeKind.ElementAccess: {\n        const expr = node as ElementAccessExpression;\n        this.visitNode(expr.expression);\n        this.visitNode(expr.elementExpression);\n        break;\n      }\n      case ASNodeKind.Function: {\n        const expr = node as FunctionExpression;\n        this.visitNode(expr.declaration);\n        break;\n      }\n      case ASNodeKind.InstanceOf: {\n        const expr = node as InstanceOfExpression;\n        this.visitNode(expr.expression);\n        break;\n      }\n      case ASNodeKind.New: {\n        const expr = node as NewExpression;\n        for (const arg of expr.args) this.visitNode(arg);\n        break;\n      }\n      case ASNodeKind.Parenthesized: {\n        const expr = node as ParenthesizedExpression;\n        this.visitNode(expr.expression);\n        break;\n      }\n      case ASNodeKind.PropertyAccess: {\n        const expr = node as PropertyAccessExpression;\n        this.visitNode(expr.expression);\n        break;\n      }\n      case ASNodeKind.Ternary: {\n        const expr = node as TernaryExpression;\n        this.visitNode(expr.condition);\n        this.visitNode(expr.ifThen);\n        this.visitNode(expr.ifElse);\n        break;\n      }\n      case ASNodeKind.UnaryPostfix: {\n        const expr = node as UnaryPostfixExpression;\n        this.visitNode(expr.operand);\n        break;\n      }\n      case ASNodeKind.UnaryPrefix: {\n        const expr = node as UnaryPrefixExpression;\n        this.visitNode(expr.operand);\n        break;\n      }\n\n      // Statements with no interesting children\n      case ASNodeKind.Break:\n      case ASNodeKind.Continue:\n      case ASNodeKind.Empty:\n      case ASNodeKind.Export:\n      case ASNodeKind.ExportDefault:\n      case ASNodeKind.ExportImport:\n      case ASNodeKind.Import:\n      case ASNodeKind.Module:\n        break;\n\n      // Statements with children\n      case ASNodeKind.Block: {\n        const stmt = node as BlockStatement;\n        for (const s of stmt.statements) this.visitNode(s);\n        break;\n      }\n      case ASNodeKind.Do: {\n        const stmt = node as DoStatement;\n        this.visitNode(stmt.body);\n        this.visitNode(stmt.condition);\n        break;\n      }\n      case ASNodeKind.Expression: {\n        const stmt = node as ExpressionStatement;\n        this.visitNode(stmt.expression);\n        break;\n      }\n      case ASNodeKind.For: {\n        const stmt = node as ForStatement;\n        if (stmt.initializer) this.visitNode(stmt.initializer);\n        if (stmt.condition) this.visitNode(stmt.condition);\n        if (stmt.incrementor) this.visitNode(stmt.incrementor);\n        this.visitNode(stmt.body);\n        break;\n      }\n      case ASNodeKind.ForOf: {\n        const stmt = node as ForOfStatement;\n        this.visitNode(stmt.variable);\n        this.visitNode(stmt.iterable);\n        this.visitNode(stmt.body);\n        break;\n      }\n      case ASNodeKind.If: {\n        const stmt = node as IfStatement;\n        this.visitNode(stmt.condition);\n        this.visitNode(stmt.ifTrue);\n        if (stmt.ifFalse) this.visitNode(stmt.ifFalse);\n        break;\n      }\n      case ASNodeKind.Return: {\n        const stmt = node as ReturnStatement;\n        if (stmt.value) this.visitNode(stmt.value);\n        break;\n      }\n      case ASNodeKind.Switch: {\n        const stmt = node as SwitchStatement;\n        this.visitNode(stmt.condition);\n        for (const switchCase of stmt.cases) this.visitNode(switchCase);\n        break;\n      }\n      case ASNodeKind.Throw: {\n        const stmt = node as ThrowStatement;\n        this.visitNode(stmt.value);\n        break;\n      }\n      case ASNodeKind.Try: {\n        const stmt = node as TryStatement;\n        for (const s of stmt.bodyStatements) this.visitNode(s);\n        if (stmt.catchStatements) {\n          for (const s of stmt.catchStatements) this.visitNode(s);\n        }\n        if (stmt.finallyStatements) {\n          for (const s of stmt.finallyStatements) this.visitNode(s);\n        }\n        break;\n      }\n      case ASNodeKind.Variable: {\n        const stmt = node as VariableStatement;\n        for (const decl of stmt.declarations) this.visitNode(decl);\n        break;\n      }\n      case ASNodeKind.Void: {\n        const stmt = node as VoidStatement;\n        this.visitNode(stmt.expression);\n        break;\n      }\n      case ASNodeKind.While: {\n        const stmt = node as WhileStatement;\n        this.visitNode(stmt.condition);\n        this.visitNode(stmt.body);\n        break;\n      }\n      case ASNodeKind.SwitchCase: {\n        const stmt = node as SwitchCase;\n        if (stmt.label) this.visitNode(stmt.label);\n        for (const s of stmt.statements) this.visitNode(s);\n        break;\n      }\n\n      // Declaration statements\n      case ASNodeKind.ImportDeclaration:\n      case ASNodeKind.TypeDeclaration:\n        break;\n\n      case ASNodeKind.ClassDeclaration: {\n        const decl = node as ClassDeclaration;\n        this.onClassEnter(decl);\n        for (const member of decl.members) this.visitNode(member);\n        this.onClassExit(decl);\n        break;\n      }\n      case ASNodeKind.EnumDeclaration: {\n        const decl = node as EnumDeclaration;\n        for (const value of decl.values) this.visitNode(value);\n        break;\n      }\n      case ASNodeKind.EnumValueDeclaration: {\n        const decl = node as EnumValueDeclaration;\n        if (decl.initializer) this.visitNode(decl.initializer);\n        break;\n      }\n      case ASNodeKind.FieldDeclaration: {\n        const decl = node as FieldDeclaration;\n        if (decl.initializer) this.visitNode(decl.initializer);\n        break;\n      }\n      case ASNodeKind.FunctionDeclaration: {\n        const decl = node as FunctionDeclaration;\n        const shouldRecurse = this.onFunctionDeclaration(decl);\n        if (shouldRecurse && decl.body) this.visitNode(decl.body);\n        break;\n      }\n      case ASNodeKind.InterfaceDeclaration: {\n        const decl = node as InterfaceDeclaration;\n        for (const member of decl.members) this.visitNode(member);\n        break;\n      }\n      case ASNodeKind.MethodDeclaration: {\n        const decl = node as MethodDeclaration;\n        const shouldRecurse = this.onMethodDeclaration(decl);\n        if (shouldRecurse && decl.body) this.visitNode(decl.body);\n        break;\n      }\n      case ASNodeKind.NamespaceDeclaration: {\n        const decl = node as NamespaceDeclaration;\n        this.onNamespaceEnter(decl);\n        for (const member of decl.members) this.visitNode(member);\n        this.onNamespaceExit(decl);\n        break;\n      }\n      case ASNodeKind.VariableDeclaration: {\n        const decl = node as VariableDeclaration;\n        const shouldRecurse = this.onVariableDeclaration(decl);\n        if (shouldRecurse && decl.initializer) this.visitNode(decl.initializer);\n        break;\n      }\n\n      // Special nodes - no action needed\n      case ASNodeKind.ExportMember:\n      case ASNodeKind.IndexSignature:\n      case ASNodeKind.Comment:\n      case ASNodeKind.Decorator:\n        break;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{compile-runner-DOMhsLQE.mjs → compile-runner-BNFHRGZO.mjs}

@@ -1,10 +1,10 @@
-import { INTERNAL_PATH_LIB_PREFIX, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS } from "./constants-DuBLuMjt.mjs";
-import { createPoolErrorFromAnyError, debug, getTestErrorFromPoolError } from "./debug-Cm1VFmaz.mjs";
+import { INTERNAL_PATH_LIB_PREFIX, POOL_ERROR_NAMES, POOL_INTERNAL_PATHS } from "./constants-DbxJ3hzg.mjs";
+import { createPoolErrorFromAnyError, debug, getTestErrorFromPoolError } from "./debug-DtRAL4rM.mjs";
 import { toForwardSlash } from "./path-utils-t9OzjXYF.mjs";
-import { failFile, getFullTaskHierarchy, prepareFileTaskForCollection } from "./vitest-file-tasks-Bn9CrWt_.mjs";
-import { getTaskLogLabel, getTaskLogPrefix } from "./vitest-tasks--ow4pacR.mjs";
-import { executeWASMDiscovery, flushRpcUpdates, reportFileCollected, reportFileError, reportFileQueued, reportUserConsoleLogs } from "./load-user-imports-B3Iy_K8k.mjs";
-import { compileAssemblyScript } from "./compiler-CIXpfKq0.mjs";
+import { failFile, getFullTaskHierarchy, prepareFileTaskForCollection } from "./vitest-file-tasks-D8sOClGX.mjs";
+import { getTaskLogLabel, getTaskLogPrefix } from "./vitest-tasks-BZ24sghI.mjs";
+import { executeWASMDiscovery, flushRpcUpdates, reportFileCollected, reportFileError, reportFileQueued, reportUserConsoleLogs } from "./load-user-imports-Bx5ZlhSm.mjs";
+import { compileAssemblyScript } from "./compiler-Dqs-qd3I.mjs";
 import { basename, relative } from "node:path";
 
 //#region src/pool-thread/runner/compile-runner.ts
@@ -30,6 +30,7 @@ async function runCompileAndDiscover(file, logModule, rpc, poolOptions, projectR
 			],
 			excludedLibraryFilePrefix: "~lib/",
 			excludedLibraryFileOverridePrefix: poolOptions._instrumentPoolInternals ? INTERNAL_PATH_LIB_PREFIX : void 0,
+			excludedInternalFunctionSubstring: "__vitest_assemblyscript_",
 			coverageMemoryPagesMin: poolOptions.coverageMemoryPagesInitial,
 			coverageMemoryPagesMax: poolOptions.coverageMemoryPagesMax,
 			debug: poolOptions.debugNative
@@ -81,4 +82,4 @@ async function runCompileAndDiscover(file, logModule, rpc, poolOptions, projectR
 
 //#endregion
 export { runCompileAndDiscover };
-//# sourceMappingURL=compile-runner-DOMhsLQE.mjs.map
+//# sourceMappingURL=compile-runner-BNFHRGZO.mjs.map