vitest-pool-assemblyscript 0.7.0 → 0.9.0

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
 */
@@ -96,7 +63,8 @@ abstract class BaseExpectMatcher<T> {
   /**
    * Checks that a value is what you expect using identity comparison. Primitives and strings
    * are compared by value, and references are checked for reference equality only (including
-   * objects, arrays, etc).
+   * objects, arrays, etc). SIMD vectors use WASM's native `==` comparison, which compares at 
+   * the bit level, ignoring lane type.
    *
    * Cross-type numeric comparisons are allowed where AssemblyScript's own `==` operator
    * permits them (e.g. `f64` vs `i32`). `toBeCloseTo()` is safer for any comparison
@@ -105,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);
@@ -116,6 +86,9 @@ abstract class BaseExpectMatcher<T> {
    * // supported float/integer comparisons (small integer types)
    * expect(f64(42.0)).toBe(i32(42));
    *
+   * // SIMD vectors: different lane types with the same underlying bits are identical
+   * expect(i64x2(3, 7)).toBe(i32x4(3, 0, 7, 0));
+   *
    * // unsupported float/integer comparisons throw an error
    * // expect(f32(42.0)).toBe(i32(42));  // Error: float precision insufficient
    * // expect(f64(42.0)).toBe(i64(42));  // Error: float precision insufficient
@@ -133,10 +106,15 @@ abstract class BaseExpectMatcher<T> {
    *
    * Strings are compared by value equality as with `toBe`. Non-numeric, non-string types return false.
    *
-   * @param precision - Specify the number of decimal places that must match for values to be 
+   * SIMD `v128` vectors are not supported, as approximate comparison requires a lane type
+   * interpretation to extract numeric values. Extract lane values as needed and compare them individually.
+   *
+   * @param precision - Specify the number of decimal places that must match for values to be
    * considered close. Defaults to 2 digits, meaning effectively that values must be within 0.005 of
    * each other.
    *
+   * @throws When either value is a `v128` vector.
+   *
    * @example
    * expect(0.1 + 0.2).toBeCloseTo(0.3);
    * expect(1.005).toBeCloseTo(1.0, 1);
@@ -153,11 +131,14 @@ abstract class BaseExpectMatcher<T> {
    * (more permissive than AS's own `>` operator). Booleans are treated as numeric
    * (true=1, false=0).
    *
+   * SIMD `v128` vectors are not supported, as numeric lane-wise comparison requires a 
+   * specific lane type interpretation. Extract lane values and compare them individually instead.
+   *
    * @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 nullable strings where either value is null. Use `toBeNull()`
    * to check for null values.
-   * @throws When comparing non-string reference types (objects, arrays, etc).
+   * @throws When comparing non-string reference types (objects, arrays, etc) or `v128` vectors.
    *
    * @example
    * expect(10).toBeGreaterThan(5);
@@ -179,11 +160,14 @@ abstract class BaseExpectMatcher<T> {
    * (more permissive than AS's own `>=` operator). Booleans are treated as numeric
    * (true=1, false=0).
    *
+   * SIMD `v128` vectors are not supported, as numeric lane-wise comparison requires a 
+   * specific lane type interpretation. Extract lane values and compare them individually instead.
+   *
    * @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 nullable strings where either value is null. Use `toBeNull()`
    * to check for null values.
-   * @throws When comparing non-string reference types (objects, arrays, etc).
+   * @throws When comparing non-string reference types (objects, arrays, etc) or `v128` vectors.
    *
    * @example
    * expect(10).toBeGreaterThanOrEqual(10);
@@ -204,11 +188,14 @@ abstract class BaseExpectMatcher<T> {
    * (more permissive than AS's own `<` operator). Booleans are treated as numeric
    * (true=1, false=0).
    *
+   * SIMD `v128` vectors are not supported, as numeric lane-wise comparison requires a 
+   * specific lane type interpretation. Extract lane values and compare them individually instead.
+   *
    * @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 nullable strings where either value is null. Use `toBeNull()`
    * to check for null values.
-   * @throws When comparing non-string reference types (objects, arrays, etc).
+   * @throws When comparing non-string reference types (objects, arrays, etc) or `v128` vectors.
    *
    * @example
    * expect(5).toBeLessThan(10);
@@ -230,11 +217,14 @@ abstract class BaseExpectMatcher<T> {
    * (more permissive than AS's own `<=` operator). Booleans are treated as numeric
    * (true=1, false=0).
    *
+   * SIMD `v128` vectors are not supported, as numeric lane-wise comparison requires a 
+   * specific lane type interpretation. Extract lane values and compare them individually instead.
+   *
    * @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 nullable strings where either value is null. Use `toBeNull()`
    * to check for null values.
-   * @throws When comparing non-string reference types (objects, arrays, etc).
+   * @throws When comparing non-string reference types (objects, arrays, etc) or `v128` vectors.
    *
    * @example
    * expect(5).toBeLessThanOrEqual(5);
@@ -248,42 +238,119 @@ abstract class BaseExpectMatcher<T> {
   }
 
   /**
-   * Checks that two values have the same value (deep equality). Currently supports
-   * checking equality of Arrays, Sets, Maps, and nulls. Values inside arrays are
-   * compared using `toEqual()` also, while Maps and Sets use their respective rules
-   * for membership. Primitives, strings, and other object references are compared with
-   * `toBe()` rules.
-   *
+   * Checks that two values have the same value (deep equality). Primitives and strings
+   * 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.
-   *
-   * ⚠️ IMPORTANT: Does not yet support user-defined object deep equality checking.
+   * 
+   * 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]);
    * expect(["one", "two", "three"]).toEqual(["one", "two", "three"]);
    *
-   * // objects use reference equality (deep equality not yet supported)
-   * const a: MyObject = new MyObject();
-   * const b: MyObject = new MyObject();
-   * expect([a, b]).toEqual([a, b]);
+   * // ArrayBuffer byte-level comparison
+   * const a = new ArrayBuffer(4);
+   * const b = new ArrayBuffer(4);
+   * store<u8>(changetype<usize>(a), 0x42);
+   * store<u8>(changetype<usize>(b), 66);  // 66 decimal == 0x42 hex
+   * expect(a).toEqual(b);
+   *
+   * // 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: 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);
   }
 
   /**
@@ -293,10 +360,13 @@ abstract class BaseExpectMatcher<T> {
    * an object reference, not a primitive. An empty string is still an allocated object
    * with a non-zero address, so it evaluates as truthy.
    *
+   * A SIMD `v128` vector with at least one non-zero bit is truthy; an all-zero vector is falsy.
+   *
    * @example
    * expect(1).toBeTruthy();
    * expect("hello").toBeTruthy();
    * expect("").toBeTruthy();  // truthy in AS (unlike JS)
+   * expect(i32x4.splat(1)).toBeTruthy();
    */
   toBeTruthy(): void {
     this.assertComparison(truthyOrFalsey(this.actual, true), this.actual, true, "to be truthy", false);
@@ -309,11 +379,14 @@ abstract class BaseExpectMatcher<T> {
    * an object reference, not a primitive. An empty string is still an allocated object
    * with a non-zero address, so it evaluates as truthy.
    *
+   * An all-zero SIMD `v128` vector is falsy; a vector with at least one non-zero bit is truthy.
+   *
    * @example
    * expect(0).toBeFalsy();
    * expect(NaN).toBeFalsy();
    * expect(null).toBeFalsy();
    * expect("").not.toBeFalsy();  // not falsy in AS (unlike JS)
+   * expect(i32x4.splat(0)).toBeFalsy();
    */
   toBeFalsy(): void {
     this.assertComparison(truthyOrFalsey(this.actual, false), this.actual, false, "to be falsey", false);
@@ -340,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
@@ -406,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/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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"}