as-test 1.0.7 → 1.0.9

package/README.md

@@ -243,6 +243,17 @@ fuzz("hot path stays stable", (): void => {
 }, 250);
 ```
 
+Or pass it as the second argument to `.generate(...)`:
+
+```ts
+fuzz("ascii strings survive concatenation boundaries", (input: string): bool => {
+  expect(input.length <= 40).toBe(true);
+  return true;
+}).generate((seed: FuzzSeed, run: (input: string) => bool): void => {
+  run(seed.string({ charset: "ascii", min: 0, max: 40 }));
+}, 250);
+```
+
 You can still override fuzz runs from the CLI when you want to force a different count for the current command:
 
 ```bash

package/assembly/__fuzz__/string.fuzz.ts

@@ -18,4 +18,4 @@ fuzz(
       exclude: [0x00, 0x0a, 0x0d],
     }),
   );
-});
+}, 250);

package/assembly/as-test.intellisense.d.ts

@@ -0,0 +1,60 @@
+export {};
+
+declare module "as-test" {
+  export interface IntellisenseIntegerOptions {
+    min?: number;
+    max?: number;
+    exclude?: number[];
+  }
+
+  export interface IntellisenseFloatOptions {
+    min?: number;
+    max?: number;
+    exclude?: number[];
+  }
+
+  export interface IntellisenseBytesOptions {
+    min?: number;
+    max?: number;
+    include?: number[];
+    exclude?: number[];
+  }
+
+  export interface IntellisenseStringOptions {
+    charset?:
+      | "ascii"
+      | "alpha"
+      | "alnum"
+      | "digit"
+      | "hex"
+      | "base64"
+      | "identifier"
+      | "whitespace"
+      | "custom";
+    min?: number;
+    max?: number;
+    include?: number[];
+    exclude?: number[];
+    prefix?: string;
+    suffix?: string;
+  }
+
+  export interface IntellisenseArrayOptions {
+    min?: number;
+    max?: number;
+  }
+
+  export interface FuzzSeed {
+    i32(options?: IntellisenseIntegerOptions): number;
+    u32(options?: IntellisenseIntegerOptions): number;
+    f32(options?: IntellisenseFloatOptions): number;
+    f64(options?: IntellisenseFloatOptions): number;
+    bytes(options?: IntellisenseBytesOptions): Uint8Array;
+    buffer(options?: IntellisenseBytesOptions): ArrayBuffer;
+    string(options?: IntellisenseStringOptions): string;
+    array<T>(
+      item: (seed: FuzzSeed) => T,
+      options?: IntellisenseArrayOptions,
+    ): Array<T>;
+  }
+}

package/assembly/src/fuzz.ts

@@ -193,7 +193,8 @@ export abstract class FuzzerBase {
     this.operations = operations > 0 ? operations : 0;
   }
 
-  generate<T extends Function>(_generator: T): this {
+  generate<T extends Function>(_generator: T, operations: i32 = 0): this {
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -389,14 +390,19 @@ export class Fuzzer0<R> extends FuzzerBase {
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: () => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
-  generateTyped(generator: (seed: FuzzSeed, run: () => R) => void): this {
+  generateTyped(
+    generator: (seed: FuzzSeed, run: () => R) => void,
+    operations: i32 = 0,
+  ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -444,14 +450,19 @@ export class Fuzzer1<A, R> extends FuzzerBase {
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: (a: A) => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
-  generateTyped(generator: (seed: FuzzSeed, run: (a: A) => R) => void): this {
+  generateTyped(
+    generator: (seed: FuzzSeed, run: (a: A) => R) => void,
+    operations: i32 = 0,
+  ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -508,16 +519,19 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: (a: A, b: B) => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
   generateTyped(
     generator: (seed: FuzzSeed, run: (a: A, b: B) => R) => void,
+    operations: i32 = 0,
   ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -574,15 +588,18 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator = changetype<usize>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
   generateTyped(
     generator: (seed: FuzzSeed, run: (a: A, b: B, c: C) => R) => void,
+    operations: i32 = 0,
   ): this {
     this.generator = changetype<usize>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 

package/bin/commands/init-core.js

@@ -396,6 +396,10 @@ function printPlan(root, target, example, fuzzExample, install) {
             path: ".as-test/runners/default.bindings.js",
             isDir: false,
         });
+        fileEntries.push({
+            path: ".as-test/runners/default.bindings.hooks.js",
+            isDir: false,
+        });
         fileEntries.push({
             path: ".as-test/runners/default.wasi.js",
             isDir: false,
@@ -404,6 +408,10 @@ function printPlan(root, target, example, fuzzExample, install) {
             path: ".as-test/runners/default.web.js",
             isDir: false,
         });
+        fileEntries.push({
+            path: ".as-test/runners/default.web.hooks.js",
+            isDir: false,
+        });
     }
     if (example != "none") {
         fileEntries.push({
@@ -514,10 +522,18 @@ function applyInit(root, target, example, fuzzExample, force) {
         const runnerPath = path.join(root, ".as-test/runners/default.bindings.js");
         writeManagedFile(runnerPath, buildBindingsRunner(), force, summary, ".as-test/runners/default.bindings.js");
     }
+    if (target == "wasi" || target == "bindings" || target == "web") {
+        const hooksPath = path.join(root, ".as-test/runners/default.bindings.hooks.js");
+        writeManagedFile(hooksPath, buildBindingsRunnerHooks(), force, summary, ".as-test/runners/default.bindings.hooks.js");
+    }
     if (target == "wasi" || target == "bindings" || target == "web") {
         const runnerPath = path.join(root, ".as-test/runners/default.web.js");
         writeManagedFile(runnerPath, buildWebRunnerSource(), force, summary, ".as-test/runners/default.web.js");
     }
+    if (target == "wasi" || target == "bindings" || target == "web") {
+        const hooksPath = path.join(root, ".as-test/runners/default.web.hooks.js");
+        writeManagedFile(hooksPath, buildWebRunnerHooks(), force, summary, ".as-test/runners/default.web.hooks.js");
+    }
     const pkgPath = path.join(root, "package.json");
     const pkg = existsSync(pkgPath)
         ? JSON.parse(readFileSync(pkgPath, "utf8"))
@@ -1028,7 +1044,10 @@ function buildBindingsRunner() {
 import path from "path";
 import { pathToFileURL } from "url";
 
-let patched = false;
+const HOOKS_PATH = path.resolve(
+  path.dirname(new URL(import.meta.url).pathname),
+  "./default.bindings.hooks.js",
+);
 
 function readExact(length) {
   const out = Buffer.alloc(length);
@@ -1055,20 +1074,76 @@ function writeRaw(data) {
   fs.writeSync(1, view);
 }
 
-function withNodeIo(imports = {}) {
-  if (!patched) {
-    patched = true;
-    const originalWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = (chunk, ...args) => {
-      if (chunk instanceof ArrayBuffer) {
-        writeRaw(chunk);
-        return true;
-      }
-      return originalWrite(chunk, ...args);
+function createRunnerContext({ wasmPath, module, helperPath }) {
+  return {
+    wasmPath,
+    helperPath,
+    module,
+    argv: process.argv.slice(2),
+    env: process.env,
+    readFrame(size) {
+      return readExact(Number(size ?? 0));
+    },
+    writeFrame(data) {
+      writeRaw(data);
+      return true;
+    },
+  };
+}
+
+function createAsTestImports(ctx) {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk, ...args) => {
+    if (chunk instanceof ArrayBuffer) {
+      return ctx.writeFrame(chunk);
+    }
+    return originalWrite(chunk, ...args);
+  };
+  process.stdin.read = (size) => ctx.readFrame(size);
+  return {};
+}
+
+function mergeImports(...groups) {
+  const out = {};
+  for (const group of groups) {
+    if (!group || typeof group != "object") continue;
+    for (const moduleName of Object.keys(group)) {
+      out[moduleName] = Object.assign(out[moduleName] || {}, group[moduleName]);
+    }
+  }
+  return out;
+}
+
+async function loadRunnerHooks() {
+  if (!fs.existsSync(HOOKS_PATH)) {
+    return {
+      createUserImports() {
+        return {};
+      },
+      async runModule(_exports, _ctx) {},
     };
-    process.stdin.read = (size) => readExact(Number(size ?? 0));
   }
-  return imports;
+  const mod = await import(pathToFileURL(HOOKS_PATH).href + "?t=" + Date.now());
+  return {
+    createUserImports:
+      typeof mod.createUserImports == "function"
+        ? mod.createUserImports
+        : () => ({}),
+    runModule:
+      typeof mod.runModule == "function" ? mod.runModule : async () => {},
+  };
+}
+
+async function instantiateModule(ctx, hooks) {
+  const helper = await import(pathToFileURL(ctx.helperPath).href);
+  if (typeof helper.instantiate !== "function") {
+    throw new Error("bindings helper missing instantiate export");
+  }
+  const imports = mergeImports(
+    createAsTestImports(ctx),
+    await hooks.createUserImports(ctx),
+  );
+  return helper.instantiate(ctx.module, imports);
 }
 
 const wasmPathArg = process.argv[2];
@@ -1083,14 +1158,49 @@ const jsPath = wasmPath.replace(/\\.wasm$/, ".js");
 try {
   const binary = fs.readFileSync(wasmPath);
   const module = new WebAssembly.Module(binary);
-  const mod = await import(pathToFileURL(jsPath).href);
-  if (typeof mod.instantiate !== "function") {
-    throw new Error("bindings helper missing instantiate export");
-  }
-  mod.instantiate(module, withNodeIo({}));
+  const ctx = createRunnerContext({ wasmPath, module, helperPath: jsPath });
+  const hooks = await loadRunnerHooks();
+  const exports = await instantiateModule(ctx, hooks);
+  await hooks.runModule(exports, ctx);
 } catch (error) {
   process.stderr.write("failed to run bindings module: " + String(error) + "\\n");
   process.exit(1);
 }
 `;
 }
+function buildBindingsRunnerHooks() {
+    return `export function createUserImports(_ctx) {
+  return {
+    // env: {
+    //   now_ms: () => Date.now(),
+    // },
+  };
+}
+
+export async function runModule(_exports, _ctx) {
+  // The generated bindings helper already calls exports._start().
+  // Add extra startup calls here when your module exposes them.
+  //
+  // Example:
+  // _exports.run?.();
+}
+`;
+}
+function buildWebRunnerHooks() {
+    return `export function createUserImports(_ctx) {
+  return {
+    // env: {
+    //   now_ms: () => performance.now(),
+    // },
+  };
+}
+
+export async function runModule(_exports, _ctx) {
+  // The generated bindings helper already calls exports._start().
+  // Add extra startup calls here when your module exposes them.
+  //
+  // Example:
+  // _exports.run?.();
+}
+`;
+}

package/bin/commands/run-core.js

@@ -6,7 +6,7 @@ import { applyMode, formatTime, getExec, loadConfig, tokenizeCommand, } from "..
 import * as path from "path";
 import { pathToFileURL } from "url";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { buildWebRunnerSource } from "./web-runner-source.js";
+import { buildWebRunnerHooksSource, buildWebRunnerSource, } from "./web-runner-source.js";
 import { createReporter as createDefaultReporter } from "../reporters/default.js";
 import { createTapReporter } from "../reporters/tap.js";
 import { persistCrashRecord } from "../crash-store.js";
@@ -579,9 +579,27 @@ function applyConfiguredFileTotalToStats(stats, fileSummaryTotal) {
     stats.skippedFiles += unexecuted;
 }
 function resolveRuntimeCommand(runtimeRun, target, emitWarnings = true) {
-    const normalized = resolveLegacyRuntime(runtimeRun, target, emitWarnings);
+    const targetDefaultAligned = alignDefaultRuntimeToTarget(runtimeRun, target);
+    const normalized = resolveLegacyRuntime(targetDefaultAligned, target, emitWarnings);
     return fallbackToDefaultRuntime(normalized, target, emitWarnings);
 }
+function alignDefaultRuntimeToTarget(runtimeRun, target) {
+    const fallback = getDefaultRuntimeFallback(target);
+    if (!fallback)
+        return runtimeRun;
+    const trimmed = runtimeRun.trim();
+    if (!trimmed.length || trimmed == fallback.command)
+        return runtimeRun;
+    const defaults = ["wasi", "bindings", "web"]
+        .map((kind) => getDefaultRuntimeFallback(kind))
+        .filter((item) => item != null);
+    for (const entry of defaults) {
+        if (entry.command != fallback.command && entry.command == trimmed) {
+            return fallback.command;
+        }
+    }
+    return runtimeRun;
+}
 function resolveLegacyRuntime(runtimeRun, target, emitWarnings) {
     if (target == "wasi") {
         const preferredPath = "./.as-test/runners/default.wasi.js";
@@ -682,8 +700,10 @@ function ensureDefaultRuntimeRunner(target, emitWarnings) {
     if (!fallback)
         return null;
     const resolvedScriptPath = path.join(process.cwd(), fallback.scriptPath);
-    if (existsSync(resolvedScriptPath))
+    if (existsSync(resolvedScriptPath)) {
+        ensureDefaultRuntimeHookFiles(target);
         return fallback;
+    }
     const source = getDefaultRuntimeRunnerSource(target);
     if (!source)
         return fallback;
@@ -694,8 +714,39 @@ function ensureDefaultRuntimeRunner(target, emitWarnings) {
     if (emitWarnings) {
         process.stderr.write(chalk.dim(`runtime script missing; created ${fallback.scriptPath}\n`));
     }
+    ensureDefaultRuntimeHookFiles(target);
     return fallback;
 }
+function ensureDefaultRuntimeHookFiles(target) {
+    const hooks = getDefaultRuntimeRunnerHookFiles(target);
+    for (const file of hooks) {
+        if (existsSync(file.path))
+            continue;
+        if (!existsSync(path.dirname(file.path))) {
+            mkdirSync(path.dirname(file.path), { recursive: true });
+        }
+        writeFileSync(file.path, file.source);
+    }
+}
+function getDefaultRuntimeRunnerHookFiles(target) {
+    if (target == "bindings") {
+        return [
+            {
+                path: path.join(process.cwd(), "./.as-test/runners/default.bindings.hooks.js"),
+                source: getDefaultBindingsRunnerHooksSource(),
+            },
+        ];
+    }
+    if (target == "web") {
+        return [
+            {
+                path: path.join(process.cwd(), "./.as-test/runners/default.web.hooks.js"),
+                source: buildWebRunnerHooksSource(),
+            },
+        ];
+    }
+    return [];
+}
 function getDefaultRuntimeRunnerSource(target) {
     if (target == "wasi") {
         return `import { readFileSync } from "fs";
@@ -758,7 +809,10 @@ try {
 import path from "path";
 import { pathToFileURL } from "url";
 
-let patched = false;
+const HOOKS_PATH = path.resolve(
+  path.dirname(new URL(import.meta.url).pathname),
+  "./default.bindings.hooks.js",
+);
 
 function readExact(length) {
   const out = Buffer.alloc(length);
@@ -785,20 +839,76 @@ function writeRaw(data) {
   fs.writeSync(1, view);
 }
 
-function withNodeIo(imports = {}) {
-  if (!patched) {
-    patched = true;
-    const originalWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = (chunk, ...args) => {
-      if (chunk instanceof ArrayBuffer) {
-        writeRaw(chunk);
-        return true;
-      }
-      return originalWrite(chunk, ...args);
+function createRunnerContext({ wasmPath, module, helperPath }) {
+  return {
+    wasmPath,
+    helperPath,
+    module,
+    argv: process.argv.slice(2),
+    env: process.env,
+    readFrame(size) {
+      return readExact(Number(size ?? 0));
+    },
+    writeFrame(data) {
+      writeRaw(data);
+      return true;
+    },
+  };
+}
+
+function createAsTestImports(ctx) {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk, ...args) => {
+    if (chunk instanceof ArrayBuffer) {
+      return ctx.writeFrame(chunk);
+    }
+    return originalWrite(chunk, ...args);
+  };
+  process.stdin.read = (size) => ctx.readFrame(size);
+  return {};
+}
+
+function mergeImports(...groups) {
+  const out = {};
+  for (const group of groups) {
+    if (!group || typeof group != "object") continue;
+    for (const moduleName of Object.keys(group)) {
+      out[moduleName] = Object.assign(out[moduleName] || {}, group[moduleName]);
+    }
+  }
+  return out;
+}
+
+async function loadRunnerHooks() {
+  if (!fs.existsSync(HOOKS_PATH)) {
+    return {
+      createUserImports() {
+        return {};
+      },
+      async runModule(_exports, _ctx) {},
     };
-    process.stdin.read = (size) => readExact(Number(size ?? 0));
   }
-  return imports;
+  const mod = await import(pathToFileURL(HOOKS_PATH).href + "?t=" + Date.now());
+  return {
+    createUserImports:
+      typeof mod.createUserImports == "function"
+        ? mod.createUserImports
+        : () => ({}),
+    runModule:
+      typeof mod.runModule == "function" ? mod.runModule : async () => {},
+  };
+}
+
+async function instantiateModule(ctx, hooks) {
+  const helper = await import(pathToFileURL(ctx.helperPath).href);
+  if (typeof helper.instantiate !== "function") {
+    throw new Error("bindings helper missing instantiate export");
+  }
+  const imports = mergeImports(
+    createAsTestImports(ctx),
+    await hooks.createUserImports(ctx),
+  );
+  return helper.instantiate(ctx.module, imports);
 }
 
 const wasmPathArg = process.argv[2];
@@ -813,11 +923,10 @@ const jsPath = wasmPath.replace(/\\.wasm$/, ".js");
 try {
   const binary = fs.readFileSync(wasmPath);
   const module = new WebAssembly.Module(binary);
-  const mod = await import(pathToFileURL(jsPath).href);
-  if (typeof mod.instantiate !== "function") {
-    throw new Error("bindings helper missing instantiate export");
-  }
-  mod.instantiate(module, withNodeIo({}));
+  const ctx = createRunnerContext({ wasmPath, module, helperPath: jsPath });
+  const hooks = await loadRunnerHooks();
+  const exports = await instantiateModule(ctx, hooks);
+  await hooks.runModule(exports, ctx);
 } catch (error) {
   process.stderr.write("failed to run bindings module: " + String(error) + "\\n");
   process.exit(1);
@@ -829,6 +938,24 @@ try {
     }
     return null;
 }
+function getDefaultBindingsRunnerHooksSource() {
+    return `export function createUserImports(_ctx) {
+  return {
+    // env: {
+    //   now_ms: () => Date.now(),
+    // },
+  };
+}
+
+export async function runModule(_exports, _ctx) {
+  // The generated bindings helper already calls exports._start().
+  // Add extra startup calls here when your module exposes them.
+  //
+  // Example:
+  // _exports.run?.();
+}
+`;
+}
 function resolveArtifactFileName(file, target, modeName, duplicateSpecBasenames = new Set()) {
     const base = path
         .basename(file)

package/bin/commands/web-runner-source.js

@@ -1,3 +1,21 @@
+export function buildWebRunnerHooksSource() {
+    return `export function createUserImports(_ctx) {
+  return {
+    // env: {
+    //   now_ms: () => performance.now(),
+    // },
+  };
+}
+
+export async function runModule(_exports, _ctx) {
+  // The generated bindings helper already calls exports._start().
+  // Add extra startup calls here when your module exposes them.
+  //
+  // Example:
+  // _exports.run?.();
+}
+`;
+}
 export function buildWebRunnerSource() {
     const html = String.raw `<!doctype html>
 <html lang="en">
@@ -135,6 +153,7 @@ ws.addEventListener("open", () => {
   worker.postMessage({
     kind: "init",
     helperUrl: "/artifact.js",
+    hooksUrl: "/runner-hooks.js",
     wasmUrl: "/artifact.wasm",
     replyBuffer,
   });
@@ -165,32 +184,61 @@ ws.addEventListener("error", () => {
     const worker = String.raw `let replyState = null;
 let replyBytes = null;
 
-self.onmessage = async (event) => {
-  const message = event.data ?? {};
-  if (message.kind != "init") {
-    return;
-  }
-
-  const shared = message.replyBuffer;
-  replyState = new Int32Array(shared, 0, 2);
-  replyBytes = new Uint8Array(shared, 8);
+function createRunnerContext({ helperUrl, wasmUrl, module }) {
+  return {
+    helperUrl,
+    wasmUrl,
+    module,
+    postFrame(frame) {
+      self.postMessage({ kind: "wipc", frame }, [frame]);
+      return true;
+    },
+    readFrame(size) {
+      return readReply(Number(size ?? 0));
+    },
+  };
+}
 
+function createAsTestImports(ctx) {
   globalThis.process = {
     stdout: {
       write(data) {
         const frame = data instanceof ArrayBuffer ? data : data?.buffer;
-        self.postMessage({ kind: "wipc", frame }, [frame]);
-        return true;
+        return ctx.postFrame(frame);
       },
     },
     stdin: {
       read(size) {
-        return readReply(Number(size ?? 0));
+        return ctx.readFrame(size);
       },
     },
   };
+  return {};
+}
+
+function mergeImports(...groups) {
+  const out = {};
+  for (const group of groups) {
+    if (!group || typeof group != "object") continue;
+    for (const moduleName of Object.keys(group)) {
+      out[moduleName] = Object.assign(out[moduleName] || {}, group[moduleName]);
+    }
+  }
+  return out;
+}
+
+self.onmessage = async (event) => {
+  const message = event.data ?? {};
+  if (message.kind != "init") {
+    return;
+  }
+
+  const shared = message.replyBuffer;
+  replyState = new Int32Array(shared, 0, 2);
+  replyBytes = new Uint8Array(shared, 8);
 
   try {
+    const hooks = await import(message.hooksUrl);
     const helper = await import(message.helperUrl);
     if (typeof helper.instantiate != "function") {
       throw new Error("bindings helper missing instantiate export");
@@ -201,8 +249,22 @@ self.onmessage = async (event) => {
     }
     const binary = await response.arrayBuffer();
     const module = new WebAssembly.Module(binary);
+    const ctx = createRunnerContext({
+      helperUrl: message.helperUrl,
+      wasmUrl: message.wasmUrl,
+      module,
+    });
+    const imports = mergeImports(
+      createAsTestImports(ctx),
+      typeof hooks.createUserImports == "function"
+        ? await hooks.createUserImports(ctx)
+        : {},
+    );
     self.postMessage({ kind: "ready" });
-    await helper.instantiate(module, {});
+    const exports = await helper.instantiate(module, imports);
+    if (typeof hooks.runModule == "function") {
+      await hooks.runModule(exports, ctx);
+    }
     self.postMessage({ kind: "done" });
   } catch (error) {
     const message =
@@ -235,6 +297,7 @@ function readReply(max) {
   return out.buffer;
 }
 `;
+    const hooks = buildWebRunnerHooksSource();
     return `import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import http from "http";
@@ -244,6 +307,7 @@ import { spawn } from "child_process";
 const INDEX_HTML = ${JSON.stringify(html)};
 const CLIENT_JS = ${JSON.stringify(client)};
 const WORKER_JS = ${JSON.stringify(worker)};
+const DEFAULT_HOOKS_JS = ${JSON.stringify(hooks)};
 const MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 const HEADLESS_FLAGS = [
   "--headless=new",
@@ -264,6 +328,7 @@ if (!wasmArg) {
 
 const wasmPath = path.resolve(process.cwd(), wasmArg);
 const helperPath = wasmPath.replace(/\\.wasm$/, ".js");
+const hooksPath = path.resolve(process.cwd(), ".as-test/runners/default.web.hooks.js");
 if (!existsSync(wasmPath)) {
   process.stderr.write("missing wasm artifact: " + wasmPath + "\\n");
   process.exit(1);
@@ -321,6 +386,14 @@ const server = http.createServer((req, res) => {
     res.end(readFileSync(helperPath, "utf8"));
     return;
   }
+  if (url == "/runner-hooks.js") {
+    res.writeHead(200, {
+      ...headers,
+      "Content-Type": "text/javascript; charset=utf-8",
+    });
+    res.end(existsSync(hooksPath) ? readFileSync(hooksPath, "utf8") : DEFAULT_HOOKS_JS);
+    return;
+  }
   if (url == "/artifact.wasm") {
     res.writeHead(200, {
       ...headers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -39,6 +39,7 @@
   "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings",
   "files": [
     "assembly/**/*.ts",
+    "assembly/**/*.d.ts",
     "!assembly/__tests__/**",
     "!assembly/tsconfig.json",
     "bin/**/*.js",