as-test 1.3.0 → 1.4.0

package/assembly/src/reflect.ts

@@ -0,0 +1,122 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+
+// Structural equality entry point. Modelled on as-pect's Reflect.equals,
+// trimmed of memoisation cache and ignore-list bookkeeping — those live
+// in the per-class methods emitted by the EqualsTransform.
+//
+// Per-call flow:
+//   * primitives, strings, booleans → `===`
+//   * nullables → resolve null on either side, then fall through
+//   * arrays → length + element-wise recursion with the same `stack`
+//   * managed values → identity short-circuit, optional `rtId` check
+//     for strict mode, cycle detection via `stack`, then dispatch to
+//     the class's `__AS_TEST_EQUALS(other, stack, ignore, strict)`
+//
+// `right` is forwarded with its full static type so the dispatched
+// method's body reads fields directly via AS virtual dispatch.
+
+export function reflectEquals<T>(
+  left: T,
+  right: T,
+  stack: usize[],
+  strict: bool,
+): bool {
+  if (isBoolean<T>() || isInteger<T>() || isFloat<T>() || isString<T>())
+    return left === right;
+
+  if (isNullable<T>()) {
+    const lp = changetype<usize>(left);
+    const rp = changetype<usize>(right);
+    if (lp == 0 || rp == 0) return lp == rp;
+  }
+
+  if (isArray<T>()) {
+    // @ts-expect-error: type
+    const aLen = (left as valueof<T>[]).length;
+    // @ts-expect-error: type
+    const bLen = (right as valueof<T>[]).length;
+    if (aLen != bLen) return false;
+    for (let i = 0; i < aLen; i++) {
+      if (
+        // @ts-expect-error: type
+        !reflectEquals<valueof<T>>(
+          // @ts-expect-error: type
+          unchecked((left as valueof<T>[])[i]),
+          // @ts-expect-error: type
+          unchecked((right as valueof<T>[])[i]),
+          stack,
+          strict,
+        )
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  if (isManaged<T>()) {
+    const lp = changetype<usize>(left);
+    const rp = changetype<usize>(right);
+    if (lp == rp) return true;
+    if (lp == 0 || rp == 0) return false;
+
+    if (strict) {
+      const lo = changetype<OBJECT>(lp - TOTAL_OVERHEAD);
+      const ro = changetype<OBJECT>(rp - TOTAL_OVERHEAD);
+      if (lo.rtId != ro.rtId) return false;
+    }
+
+    for (let i = 0; i < stack.length; i += 2) {
+      if (unchecked(stack[i]) == lp && unchecked(stack[i + 1]) == rp)
+        return true;
+    }
+
+    stack.push(lp);
+    stack.push(rp);
+
+    // Pass `right` with its full static type so the dispatched method's
+    // body can read fields directly. For nullable T, strip the
+    // nullability with `!` — we returned early above if either operand
+    // was null, so `right!` is safe at this point.
+    //
+    // The transform injects `__AS_TEST_EQUALS` on every user class the
+    // compiler reaches, but third-party generic types (Map, Set,
+    // Option<T>, …) don't carry it. Fall back to the class's `==`
+    // operator (which the user can overload via `@operator("==")`),
+    // collapsing to reference identity if no overload is present.
+    let passed: bool;
+    if (isNullable<T>()) {
+      // @ts-expect-error: optional method, presence is a compile-time check
+      if (isDefined(left!.__AS_TEST_EQUALS)) {
+        // @ts-expect-error: declared by transform
+        passed = left!.__AS_TEST_EQUALS(
+          right!,
+          stack,
+          [] as StaticArray<i64>,
+          strict,
+        );
+      } else {
+        passed = left == right;
+      }
+    } else {
+      // @ts-expect-error: optional method, presence is a compile-time check
+      if (isDefined(left.__AS_TEST_EQUALS)) {
+        // @ts-expect-error: declared by transform
+        passed = left.__AS_TEST_EQUALS(
+          right,
+          stack,
+          [] as StaticArray<i64>,
+          strict,
+        );
+      } else {
+        passed = left == right;
+      }
+    }
+
+    stack.pop();
+    stack.pop();
+    return passed;
+  }
+
+  return left === right;
+}

package/assembly/src/stringify.ts

@@ -0,0 +1,240 @@
+// Tiny in-tree replacement for json-as's runtime. Used for two jobs:
+//
+//   1. Stringifying user values for the wipc assertion-report payload
+//      (was `JSON.stringify<T>(value)`).
+//   2. JSON-escaping internal strings before splicing them into hand-built
+//      wire payloads (was `JSON.stringify<string>(s)`).
+//
+// Dispatch order in `stringify<T>`:
+//   * primitives / booleans / numbers   → `.toString()`
+//   * strings                           → JSON-escape + quote
+//   * nullable null                     → "null"
+//   * Date                              → quoted ISO-8601 string
+//   * ArrayBuffer                       → array of unsigned byte values
+//   * TypedArray (ArrayBufferView)      → array of element values
+//   * Array / StaticArray               → element-wise recursion
+//   * Set                               → array of values
+//   * Map                               → object with stringified keys
+//   * managed with `toJSON(): string`   → call it
+//   * managed without `toJSON()`        → "<TypeName>" placeholder
+//
+// The Date/ArrayBuffer/typed-array/StaticArray/Set/Map branches use
+// `value instanceof X` guards. In a generic function AssemblyScript resolves
+// these statically: the branch is only compiled when `T` can actually be that
+// type and pruned otherwise, so the recursive calls inside type-check against
+// the real K/V/element types.
+//
+// Classes decorated with `@json` / `@serializable` are skipped by the
+// EqualsTransform's toJSON injector. Users who want those classes to
+// render prettily in reports can add their own one-line `toJSON()`
+// (e.g. `return JSON.stringify(this);` if they've also wired up
+// `--transform json-as`). as-test itself stays json-as-free.
+
+export function stringify<T>(value: T): string {
+  if (isBoolean<T>()) return value ? "true" : "false";
+  if (isInteger<T>() || isFloat<T>()) {
+    // @ts-ignore: every numeric AS primitive carries toString()
+    return value.toString();
+  }
+  if (isString<T>()) {
+    return escape(value as string);
+  }
+
+  if (isNullable<T>() && changetype<usize>(value) == 0) return "null";
+
+  // Date → quoted ISO-8601 string (matches `JSON.stringify(new Date(...))`).
+  if (value instanceof Date) {
+    return escape((value as Date).toISOString());
+  }
+
+  // ArrayBuffer → array of its unsigned byte values. A raw buffer has no
+  // natural JSON form, so surface the bytes for debugging.
+  if (value instanceof ArrayBuffer) {
+    const view = Uint8Array.wrap(value as ArrayBuffer);
+    const len = view.length;
+    if (len == 0) return "[]";
+    let out = "[";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      out += unchecked(view[i]).toString();
+    }
+    return out + "]";
+  }
+
+  // Typed arrays (Int32Array, Float64Array, …) all extend ArrayBufferView.
+  if (value instanceof ArrayBufferView) {
+    // @ts-ignore: every typed array carries a typesafe length + indexer
+    const len = value.length;
+    if (len == 0) return "[]";
+    let out = "[";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      // @ts-ignore: element is the view's numeric valueof type
+      out += stringify(unchecked(value[i]));
+    }
+    return out + "]";
+  }
+
+  if (isArray<T>()) {
+    // @ts-ignore: typesafe length
+    const len = (value as valueof<T>[]).length;
+    if (len == 0) return "[]";
+    let out = "[";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      out += stringify<valueof<T>>(
+        // @ts-ignore: bounds-checked above
+        unchecked((value as valueof<T>[])[i]),
+      );
+    }
+    return out + "]";
+  }
+
+  // StaticArray<V> → element-wise recursion, same shape as a regular array.
+  if (value instanceof StaticArray) {
+    // @ts-ignore: typesafe length + indexer
+    const len = value.length;
+    if (len == 0) return "[]";
+    let out = "[";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      // @ts-ignore: element is the array's valueof type
+      out += stringify(unchecked(value[i]));
+    }
+    return out + "]";
+  }
+
+  // Set<V> → array of its values, in insertion order.
+  if (value instanceof Set) {
+    const vals = value.values();
+    const len = vals.length;
+    if (len == 0) return "[]";
+    let out = "[";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      out += stringify(unchecked(vals[i]));
+    }
+    return out + "]";
+  }
+
+  // Map<K,V> → JSON object. JSON object keys must be strings, so non-string
+  // keys are coerced to their `.toString()` form and quoted (e.g. a numeric
+  // key `10` becomes `"10"`, matching `JSON.stringify({ 10: ... })`).
+  if (value instanceof Map) {
+    const keys = value.keys();
+    const vals = value.values();
+    const len = keys.length;
+    if (len == 0) return "{}";
+    let out = "{";
+    for (let i = 0; i < len; i++) {
+      if (i > 0) out += ",";
+      out += jsonKey(unchecked(keys[i])) + ":" + stringify(unchecked(vals[i]));
+    }
+    return out + "}";
+  }
+
+  if (isManaged<T>()) {
+    // @ts-ignore: hand-written or transform-generated serializer
+    if (isDefined(value.toJSON)) return value.toJSON();
+    return escape("<" + nameof<T>() + ">");
+  }
+
+  // Unreachable for well-typed AS code — but emit a valid JSON string so
+  // the surrounding payload stays parsable.
+  return escape("<" + nameof<T>() + ">");
+}
+
+// JSON string escape per RFC 8259, with explicit handling for UTF-16
+// surrogates (matches json-as's serializeString behaviour).
+//
+//   * `"`, `\`, control chars U+0000..U+001F → escape sequences
+//   * valid surrogate pair (high → low)      → pass both code units through
+//   * lone surrogate (high not followed by   → emit `\uXXXX` for the
+//     low, or low without a preceding high)    single code unit
+//   * everything else                         → pass through
+export function escape(s: string): string {
+  let out = '"';
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    const c = s.charCodeAt(i);
+    if (c == 0x22 /* " */) {
+      out += '\\"';
+      continue;
+    }
+    if (c == 0x5c /* \ */) {
+      out += "\\\\";
+      continue;
+    }
+    if (c == 0x08) {
+      out += "\\b";
+      continue;
+    }
+    if (c == 0x09) {
+      out += "\\t";
+      continue;
+    }
+    if (c == 0x0a) {
+      out += "\\n";
+      continue;
+    }
+    if (c == 0x0c) {
+      out += "\\f";
+      continue;
+    }
+    if (c == 0x0d) {
+      out += "\\r";
+      continue;
+    }
+    if (c < 0x20) {
+      out += "\\u00" + hexNibble((c >>> 4) & 0xf) + hexNibble(c & 0xf);
+      continue;
+    }
+    if (c >= 0xd800 && c <= 0xdfff) {
+      // High surrogate followed by a low surrogate is a valid pair —
+      // emit both code units verbatim and skip the low surrogate index.
+      if (c <= 0xdbff && i + 1 < len) {
+        const next = s.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          out += String.fromCharCode(c);
+          out += String.fromCharCode(next);
+          i++;
+          continue;
+        }
+      }
+      // Lone surrogate — escape the single code unit.
+      out += "\\u" + hex4(<u32>c);
+      continue;
+    }
+    out += String.fromCharCode(c);
+  }
+  return out + '"';
+}
+
+// Render a Map key as a quoted JSON string. Primitive keys are coerced to
+// their textual form first; anything else falls back to the value serializer,
+// wrapped as a string so the surrounding object stays parsable.
+function jsonKey<K>(key: K): string {
+  if (isString<K>()) return escape(key as string);
+  if (isBoolean<K>()) return escape(key ? "true" : "false");
+  if (isInteger<K>() || isFloat<K>()) {
+    // @ts-ignore: numeric AS primitives carry toString()
+    return escape(key.toString());
+  }
+  return escape(stringify<K>(key));
+}
+
+
+@inline function hexNibble(n: u32): string {
+  // 0..9 → '0'..'9'; 10..15 → 'a'..'f'.
+  return String.fromCharCode(n < 10 ? 0x30 + n : 0x61 + (n - 10));
+}
+
+
+@inline function hex4(c: u32): string {
+  return (
+    hexNibble((c >>> 12) & 0xf) +
+    hexNibble((c >>> 8) & 0xf) +
+    hexNibble((c >>> 4) & 0xf) +
+    hexNibble(c & 0xf)
+  );
+}

package/assembly/src/suite.ts

@@ -2,9 +2,14 @@ import { Time } from "..";
 import { Expectation } from "./expectation";
 import { Tests } from "./tests";
 import { Log } from "./log";
-import { after_each_callback, before_each_callback } from "..";
+import {
+  after_each_callback,
+  after_each_kinds,
+  before_each_callback,
+  before_each_kinds,
+} from "..";
 import { sendSuiteEnd, sendSuiteStart } from "../util/wipc";
-import { JSON } from "json-as/assembly";
+import { escape, stringify } from "./stringify";
 
 export class Suite {
   public file: string = "unknown";
@@ -49,10 +54,8 @@ export class Suite {
   }
 
   run(): void {
-    // @ts-ignore
+    // @ts-ignore: current_suite is a @global, the parent for nested registration
     current_suite = this;
-    // @ts-ignore
-    depth++;
     this.time.start = performance.now();
     sendSuiteStart(this.file, this.depth, this.kind, this.description);
     const isSkippedCase =
@@ -73,8 +76,6 @@ export class Suite {
     if (isSkippedCase) {
       this.time.end = performance.now();
       this.verdict = "skip";
-      // @ts-ignore
-      depth--;
       sendSuiteEnd(
         this.file,
         this.depth,
@@ -85,14 +86,22 @@ export class Suite {
       return;
     }
 
-    // @ts-ignore
-    if (isTestCase && before_each_callback) before_each_callback();
+    // @ts-ignore: nullable function import resolved at runtime
+    if (
+      before_each_callback &&
+      hookFiresFor(this.kind, before_each_kinds, isTestCase)
+    ) {
+      before_each_callback();
+    }
     this.callback();
-    // @ts-ignore
-    if (isTestCase && after_each_callback) after_each_callback();
+    // @ts-ignore: nullable function import resolved at runtime
+    if (
+      after_each_callback &&
+      hookFiresFor(this.kind, after_each_kinds, isTestCase)
+    ) {
+      after_each_callback();
+    }
     this.time.end = performance.now();
-    // @ts-ignore
-    depth--;
 
     const hasOnlyChildren = this.hasOnlyChildren();
 
@@ -146,16 +155,12 @@ export class Suite {
   }
 
   skip(): void {
-    // @ts-ignore
+    // @ts-ignore: current_suite is a @global
     current_suite = this;
-    // @ts-ignore
-    depth++;
     this.time.start = performance.now();
     this.time.end = this.time.start;
     this.verdict = "skip";
     sendSuiteStart(this.file, this.depth, this.kind, this.description);
-    // @ts-ignore
-    depth--;
     sendSuiteEnd(
       this.file,
       this.depth,
@@ -172,31 +177,47 @@ export class Suite {
     return false;
   }
 
-  serialize(): string {
+  toJSON(): string {
     let out = "{";
     if (this.depth <= 0) {
-      out += '"file":' + JSON.stringify<string>(this.file) + ",";
+      out += '"file":' + escape(this.file) + ",";
     }
     out += '"order":' + this.order.toString();
-    out += ',"time":' + this.time.serialize();
-    out += ',"description":' + JSON.stringify<string>(this.description);
+    out += ',"time":' + this.time.toJSON();
+    out += ',"description":' + escape(this.description);
     out += ',"depth":' + this.depth.toString();
     out += ',"suites":' + serializeSuites(this.suites);
     out += ',"tests":' + serializeTests(this.tests);
     out += ',"logs":' + serializeLogs(this.logs);
-    out += ',"kind":' + JSON.stringify<string>(this.kind);
-    out += ',"verdict":' + JSON.stringify<string>(this.verdict);
+    out += ',"kind":' + escape(this.kind);
+    out += ',"verdict":' + escape(this.verdict);
     out += "}";
     return out;
   }
 }
 
+// Whether a beforeEach/afterEach hook should fire for a suite of `kind`. A
+// `null` kinds list (the default) restricts the hook to test cases — the caller
+// passes whether `kind` is one. An explicit list fires for exactly those kinds,
+// which is how `beforeEach(fn, ["describe", "test"])` opts grouping blocks in.
+function hookFiresFor(
+  kind: string,
+  kinds: string[] | null,
+  isTestCaseKind: bool,
+): bool {
+  if (kinds === null) return isTestCaseKind;
+  for (let i = 0; i < kinds.length; i++) {
+    if (unchecked(kinds[i]) == kind) return true;
+  }
+  return false;
+}
+
 function serializeSuites(values: Suite[]): string {
   if (!values.length) return "[]";
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;
@@ -207,7 +228,7 @@ function serializeTests(values: Tests[]): string {
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;
@@ -218,7 +239,7 @@ function serializeLogs(values: Log[]): string {
   let out = "[";
   for (let i = 0; i < values.length; i++) {
     if (i) out += ",";
-    out += unchecked(values[i]).serialize();
+    out += unchecked(values[i]).toJSON();
   }
   out += "]";
   return out;

package/assembly/src/tests.ts

@@ -1,4 +1,4 @@
-import { JSON } from "json-as/assembly";
+import { escape, stringify } from "./stringify";
 
 export class Tests {
   public order: i32 = 0;
@@ -10,24 +10,24 @@ export class Tests {
   public message: string = "";
   public location: string = "";
 
-  serialize(): string {
+  toJSON(): string {
     return (
       '{"order":' +
       this.order.toString() +
       ',"type":' +
-      JSON.stringify<string>(this.type) +
+      escape(this.type) +
       ',"verdict":' +
-      JSON.stringify<string>(this.verdict) +
+      escape(this.verdict) +
       ',"left":' +
       (this.left.length ? this.left : "null") +
       ',"right":' +
       (this.right.length ? this.right : "null") +
       ',"instr":' +
-      JSON.stringify<string>(this.instr) +
+      escape(this.instr) +
       ',"message":' +
-      JSON.stringify<string>(this.message) +
+      escape(this.message) +
       ',"location":' +
-      JSON.stringify<string>(this.location) +
+      escape(this.location) +
       "}"
     );
   }

package/assembly/util/wipc.ts

@@ -1,7 +1,7 @@
-import { JSON } from "json-as/assembly";
+import { escape } from "../src/stringify";
 
 function q(s: string): string {
-  return JSON.stringify<string>(s);
+  return escape(s);
 }
 
 // @ts-ignore

package/bin/build-worker-pool.js

@@ -24,6 +24,7 @@ export class BuildWorkerPool {
         buildCommand: args.buildCommand,
         featureToggles,
         overrides,
+        onReads: args.onReads,
         resolve,
         reject,
       });
@@ -113,6 +114,13 @@ export class BuildWorkerPool {
     worker.busy = false;
     worker.task = null;
     if (message.type == "done") {
+      if (task.onReads && message.reads?.length) {
+        try {
+          task.onReads(message.reads);
+        } catch {
+          // a misbehaving sink shouldn't poison the build pipeline.
+        }
+      }
       task.resolve();
     } else {
       task.reject(deserializeError(message.error));
@@ -134,6 +142,7 @@ export class BuildWorkerPool {
         modeName: task.modeName,
         featureToggles: task.featureToggles,
         overrides: task.overrides,
+        recordReads: !!task.onReads,
       });
     }
   }

package/bin/build-worker.js

@@ -1,8 +1,13 @@
-import { build } from "./commands/build-core.js";
-process.env.AS_TEST_BUILD_API = "1";
+import { build, buildRecorderStorage } from "./commands/build-core.js";
 process.on("message", async (message) => {
   if (!message || message.type != "build-file") return;
-  try {
+  // Force the in-process API build path inside this worker so the readFile
+  // hook is reachable. We do it on first message rather than at module load
+  // so importing this file from a test doesn't mutate the parent env.
+  process.env.AS_TEST_BUILD_API = "1";
+  const seen = new Set();
+  const collected = [];
+  const runBuild = async () => {
     await build(
       message.configPath,
       [message.file],
@@ -10,9 +15,28 @@ process.on("message", async (message) => {
       message.featureToggles,
       message.overrides,
     );
+  };
+  try {
+    if (message.recordReads) {
+      const store = {
+        // asc commonly resolves the same source twice during a build (entry
+        // lookups, transform passes). Dedupe at record time so IPC payloads
+        // stay bounded — `(mode, spec)` is constant for the worker's lifetime
+        // of this task, so a file-keyed set is sufficient.
+        record: (mode, spec, file) => {
+          if (seen.has(file)) return;
+          seen.add(file);
+          collected.push({ mode, spec, file });
+        },
+      };
+      await buildRecorderStorage.run(store, runBuild);
+    } else {
+      await runBuild();
+    }
     send({
       type: "done",
       id: message.id,
+      reads: message.recordReads ? collected : undefined,
     });
   } catch (error) {
     send({