as-test 1.0.16 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Change Log
 
+## Unreleased
+
+### Upgrading to 1.1.0
+
+- refresh generated runners with:
+
+  ```bash
+  rm -rf .as-test/runners && npx as-test init
+  ```
+
+- generated runners now use a single file per target and import `instantiate(...)` from `as-test/lib`
+- new bindings and web runners no longer use `*.hooks.js`
+- named modes now support `default: false` to make a mode manual-only
+- the repo examples and default config now use mode names like `node:wasi`, `node:bindings`, `chromium`, and `chromium:headless`
+
+### Runtime & Runners
+
+- feat: replace the split bindings/web hooks model with single-file runners that import `instantiate(...)` from `as-test/lib`, keeping bindings, WASI, and web runner syntax aligned.
+- feat: add `as-test/lib` as the shared JS runtime host layer for bindings, WASI, and web targets, with runtime artifact resolution happening out of sight before runner execution.
+- feat: autodetect bindings helper shape at runtime support level (`raw`, `esm`, or `none`) and keep the generated runner surface minimal.
+- fix: make `ast run` rebuild missing artifacts on demand instead of failing when only some selected outputs already exist.
+- fix: report real lazy-build time in `ast run` summaries instead of always printing `0us build`.
+- fix: remove build artifact copy/reuse shortcuts so each selected file/mode compiles directly, avoiding stale output reuse across modes.
+
+### Web Runtime
+
+- feat: move headful web execution to a persistent single-browser-session architecture that opens one page, runs multiple binaries through it, and keeps browser-side runtime details hidden from the runner file.
+- feat: redesign the non-headless browser page into a minimal macOS-inspired loading surface with light/dark mode support and simpler status messaging.
+- feat: make headful web runs wait for the user to open the local session URL, and expose a browser-side exit control.
+- fix: keep all browser bootstrap, asset, and websocket traffic on one local port.
+- fix: improve browser discovery and launch behavior across Chromium, Firefox, and WebKit, including Playwright cache lookup, macOS app bundle resolution, paths with spaces, and owned-process teardown.
+- fix: fail terminal-side runs when the browser side disconnects unexpectedly, and close the browser side when the websocket is lost.
+
+### WASI
+
+- fix: make the WASI stdin transport retry only on retryable WASI read errors (`AGAIN` and `INTR`), which resolves intermittent snapshot reply corruption in `node:wasi` runs.
+
+### Modes & CLI
+
+- feat: add per-mode `default: boolean` selection so modes can be included in implicit runs or kept manual-only.
+- feat: add `ast clean` to remove configured build outputs, crash reports, and logs for the selected modes.
+- fix: restore unnamed root-config execution alongside named default modes when `--mode` is omitted.
+- fix: make `ast clean --mode ...` skip shared output paths that are still owned by unselected modes instead of deleting them.
+
+### Tests
+
+- feat: add integration coverage for bindings (`raw`, `esm`, `none`), WASI, and web runtime paths, including browser-resolution regressions and single-origin web runner behavior.
+
 ## 2026-05-08 - v1.0.16
 
 - feat: modes inherit pre-declared properties if not explicitly overriden

package/README.md

@@ -2,6 +2,14 @@
 ╠═╣ ╚═╗ ══  ║  ╠═  ╚═╗  ║ 
 ╩ ╩ ╚═╝     ╩  ╚═╝ ╚═╝  ╩ </pre></h1>
 
+> **Upgrading to 1.1.0**
+>
+> See [CHANGELOG.md](./CHANGELOG.md) for upgrade notes. In most projects, refreshing generated runners is enough:
+>
+> ```bash
+> rm -rf .as-test/runners && npx as-test init
+> ```
+
 <details>
 <summary>Table of Contents</summary>
 
@@ -77,7 +85,7 @@ Minimal `as-test.config.json`:
   },
   "runOptions": {
     "runtime": {
-      "cmd": "node .as-test/runners/default.wasi.js <file>"
+      "cmd": "node .as-test/runners/default.wasi.js"
     }
   }
 }
@@ -323,7 +331,7 @@ For example, a simple WASI setup in `as-test.config.json` can look like this:
   },
   "runOptions": {
     "runtime": {
-      "cmd": "node ./.as-test/runners/default.wasi.js <file>"
+      "cmd": "node ./.as-test/runners/default.wasi.js"
     }
   }
 }
@@ -342,22 +350,41 @@ If you want to keep more than one runtime around, use modes:
   "input": ["./assembly/__tests__/*.spec.ts"],
   "modes": {
     "wasi": {
+      "default": true,
       "buildOptions": {
         "target": "wasi"
       },
       "runOptions": {
         "runtime": {
-          "cmd": "node ./.as-test/runners/default.wasi.js <file>"
+          "cmd": "node ./.as-test/runners/default.wasi.js"
         }
       }
     },
     "bindings": {
+      "default": true,
       "buildOptions": {
         "target": "bindings"
       },
       "runOptions": {
         "runtime": {
-          "cmd": "node ./.as-test/runners/default.bindings.js <file>"
+          "cmd": "node ./.as-test/runners/default.bindings.js"
+        }
+      }
+    }
+  }
+}
+```
+
+Set `"default": false` on a mode when you want to keep it available for explicit `--mode ...` runs without including it in normal runs:
+
+```json
+{
+  "modes": {
+    "web": {
+      "default": false,
+      "runOptions": {
+        "runtime": {
+          "browser": "chromium"
         }
       }
     }
@@ -365,6 +392,20 @@ If you want to keep more than one runtime around, use modes:
 }
 ```
 
+With that setup:
+
+```bash
+npx ast test
+```
+
+runs the root/default config plus any modes whose `"default"` flag is not `false`, while:
+
+```bash
+npx ast test --mode web
+```
+
+still runs the `web` mode explicitly.
+
 Modes can also be full config objects. That means a mode can override fuzzing, input globs, output aliases, runtime, build flags, and the rest of the normal config surface:
 
 ```json

package/as-test.config.schema.json

@@ -305,6 +305,11 @@
             "type": "object",
             "additionalProperties": false,
             "properties": {
+              "default": {
+                "type": "boolean",
+                "description": "Include this mode when --mode is omitted. Defaults to true.",
+                "default": true
+              },
               "$schema": {
                 "type": "string"
               },

package/assembly/util/wipc.ts

@@ -34,6 +34,8 @@ const HEADER_SIZE: i32 = 9;
 const IOV_SIZE: usize = sizeof<usize>() * 2;
 const U32_SIZE: usize = sizeof<u32>();
 const REPORT_CHUNK_BYTES: i32 = 65536;
+const WASI_ERRNO_AGAIN: i32 = 6;
+const WASI_ERRNO_INTR: i32 = 27;
 
 // @ts-ignore
 const IS_BINDINGS: bool = isDefined(AS_TEST_BINDINGS);
@@ -319,10 +321,15 @@ function wasiRead(max: i32): ArrayBuffer {
 
   store<usize>(iovPtr, changetype<usize>(out), 0);
   store<usize>(iovPtr, <usize>max, sizeof<usize>());
-  store<u32>(readPtr, 0, 0);
-
-  const errno = wasi_fd_read(0, iovPtr, 1, readPtr);
-  if (errno != 0) return new ArrayBuffer(0);
+  while (true) {
+    store<u32>(readPtr, 0, 0);
+    const errno = wasi_fd_read(0, iovPtr, 1, readPtr);
+    if (errno == WASI_ERRNO_AGAIN || errno == WASI_ERRNO_INTR) {
+      continue;
+    }
+    if (errno != 0) return new ArrayBuffer(0);
+    break;
+  }
 
   const size = <i32>load<u32>(readPtr, 0);
   if (size <= 0) return new ArrayBuffer(0);

package/bin/commands/clean-core.js

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+import { existsSync, rmSync } from "fs";
+import * as path from "path";
+import { applyMode, loadConfig } from "../util.js";
+const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+export async function clean(configPath = DEFAULT_CONFIG_PATH, modes = [undefined]) {
+    const loadedConfig = loadConfig(configPath, true);
+    const targets = new Map();
+    const ownership = buildOwnershipMap(loadedConfig);
+    for (const modeName of modes) {
+        const active = applyMode(loadedConfig, modeName).config;
+        collectTarget(targets, active.outDir, modeName, "build");
+        collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+        collectTarget(targets, active.logs, modeName, "logs");
+    }
+    let removed = 0;
+    let skipped = 0;
+    for (const [targetPath, owners] of [...targets.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const allOwners = ownership.get(targetPath) ?? owners;
+        const unselectedOwners = allOwners.filter((owner) => !owners.includes(owner));
+        if (unselectedOwners.length) {
+            skipped++;
+            process.stdout.write(`${chalk.dim("skip")} ${toRelativePath(targetPath)} ${chalk.dim(`(shared with ${unselectedOwners.join(", ")})`)}\n`);
+            continue;
+        }
+        if (!existsSync(targetPath)) {
+            skipped++;
+            process.stdout.write(`${chalk.dim("skip")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
+            continue;
+        }
+        rmSync(targetPath, { recursive: true, force: true });
+        removed++;
+        process.stdout.write(`${chalk.bgGreenBright.black(" CLEAN ")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
+    }
+    process.stdout.write(`${chalk.bold("Summary:")} removed ${removed} path(s), skipped ${skipped} missing path(s)\n`);
+}
+function buildOwnershipMap(loadedConfig) {
+    const ownership = new Map();
+    const modeNames = [
+        undefined,
+        ...Object.keys(loadedConfig.modes),
+    ];
+    for (const modeName of modeNames) {
+        const active = applyMode(loadedConfig, modeName).config;
+        collectOwnership(ownership, active.outDir, modeName, "build");
+        collectOwnership(ownership, active.fuzz.crashDir, modeName, "crashes");
+        collectOwnership(ownership, active.logs, modeName, "logs");
+    }
+    return ownership;
+}
+function collectOwnership(ownership, rawPath, modeName, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `${modeName ?? "default"}:${kind}`;
+    const existing = ownership.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    ownership.set(resolved, [owner]);
+}
+function collectTarget(targets, rawPath, modeName, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `${modeName ?? "default"}:${kind}`;
+    const existing = targets.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    targets.set(resolved, [owner]);
+}
+function ensureSafeCleanPath(resolvedPath, rawPath, kind) {
+    const cwd = path.resolve(process.cwd());
+    const relative = path.relative(cwd, resolvedPath);
+    if (!relative.length ||
+        relative == ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.parse(resolvedPath).root == resolvedPath) {
+        throw new Error(`refusing to clean unsafe ${kind} path "${rawPath}" (${resolvedPath})`);
+    }
+}
+function toRelativePath(targetPath) {
+    const relative = path.relative(process.cwd(), targetPath);
+    return relative.length ? relative : ".";
+}

package/bin/commands/clean.js

@@ -0,0 +1,6 @@
+import { clean } from "./clean-core.js";
+export { clean } from "./clean-core.js";
+export async function executeCleanCommand(configPath, selectedModes, resolveExecutionModes) {
+    const modeTargets = resolveExecutionModes(configPath, selectedModes);
+    await clean(configPath, modeTargets);
+}

package/bin/commands/init-core.js

@@ -188,7 +188,7 @@ async function runInteractiveOnboarding(options, face) {
                 },
                 {
                     value: "web",
-                    label: "web (default runner: node .as-test/runners/default.web.js <file>)",
+                    label: "web (default runner: node .as-test/runners/default.web.js)",
                 },
             ], face, "wasi"));
     if (options.target || onboardingMode == "quick") {
@@ -396,10 +396,6 @@ 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,
@@ -408,10 +404,6 @@ 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({
@@ -484,19 +476,28 @@ function applyInit(root, target, example, fuzzExample, force) {
         runOptions: {
             runtime: {
                 cmd: target == "wasi"
-                    ? "node .as-test/runners/default.wasi.js <file>"
+                    ? "node .as-test/runners/default.wasi.js"
                     : target == "bindings"
-                        ? "node .as-test/runners/default.bindings.js <file>"
-                        : "node .as-test/runners/default.web.js <file>",
+                        ? "node .as-test/runners/default.bindings.js"
+                        : "node .as-test/runners/default.web.js",
             },
             reporter: "default",
         },
         modes: target == "web"
             ? {
+                web: {
+                    default: false,
+                    runOptions: {
+                        runtime: {
+                            cmd: "node .as-test/runners/default.web.js",
+                        },
+                    },
+                },
                 "web-headless": {
+                    default: false,
                     runOptions: {
                         runtime: {
-                            cmd: "node .as-test/runners/default.web.js --headless <file>",
+                            cmd: "node .as-test/runners/default.web.js --headless",
                         },
                     },
                 },
@@ -521,18 +522,10 @@ 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"))
@@ -989,217 +982,32 @@ fuzz("basic string fuzzer", (value: string): bool => {
 `;
 }
 function buildWasiRunner() {
-    return `import { readFileSync } from "fs";
-import { WASI } from "wasi";
+    return `import { instantiate } from "as-test/lib";
 
-const originalEmitWarning = process.emitWarning.bind(process);
-process.emitWarning = ((warning, ...args) => {
-  const type = typeof args[0] == "string" ? args[0] : "";
-  const name = typeof warning?.name == "string" ? warning.name : type;
-  const message =
-    typeof warning == "string" ? warning : String(warning?.message ?? "");
-  if (
-    name == "ExperimentalWarning" &&
-    message.includes("WASI is an experimental feature")
-  ) {
-    return;
-  }
-  return originalEmitWarning(warning, ...args);
-});
-
-const wasmPath = process.argv[2];
-if (!wasmPath) {
-  process.stderr.write("usage: node ./.as-test/runners/default.wasi.js <file.wasm>\\n");
-  process.exit(1);
-}
+const imports = {};
 
-try {
-  const wasi = new WASI({
-    version: "preview1",
-    args: [wasmPath],
-    env: process.env,
-    preopens: {},
+instantiate(imports)
+  .then((instance) => {
+    instance.exports.start?.();
+    // Add extra startup logic here when needed.
+  })
+  .catch((error) => {
+    throw new Error("Failed to run WASI module: " + String(error));
   });
-
-  const binary = readFileSync(wasmPath);
-  const module = new WebAssembly.Module(binary);
-  const instance = new WebAssembly.Instance(module, {
-    env: {
-      __as_test_request_fuzz_config() {
-        return 0;
-      },
-    },
-    wasi_snapshot_preview1: wasi.wasiImport,
-  });
-  wasi.start(instance);
-} catch (error) {
-  process.stderr.write("failed to run WASI module: " + String(error) + "\\n");
-  process.exit(1);
-}
 `;
 }
 function buildBindingsRunner() {
-    return `import fs from "fs";
-import path from "path";
-import { pathToFileURL } from "url";
-
-const HOOKS_PATH = path.resolve(
-  path.dirname(new URL(import.meta.url).pathname),
-  "./default.bindings.hooks.js",
-);
+    return `import { instantiate } from "as-test/lib";
 
-function readExact(length) {
-  const out = Buffer.alloc(length);
-  let offset = 0;
-  while (offset < length) {
-    let read = 0;
-    try {
-      read = fs.readSync(0, out, offset, length - offset, null);
-    } catch (error) {
-      if (error && error.code === "EAGAIN") {
-        continue;
-      }
-      throw error;
-    }
-    if (!read) break;
-    offset += read;
-  }
-  const view = out.subarray(0, offset);
-  return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
-}
-
-function writeRaw(data) {
-  const view = Buffer.from(data);
-  fs.writeSync(1, view);
-}
-
-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;
-    },
-  };
-}
+const imports = {};
 
-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) {},
-    };
-  }
-  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];
-if (!wasmPathArg) {
-  process.stderr.write("usage: node ./.as-test/runners/default.bindings.js <file.wasm>\\n");
-  process.exit(1);
-}
-
-const wasmPath = path.resolve(process.cwd(), wasmPathArg);
-const jsPath = wasmPath.replace(/\\.wasm$/, ".js");
-
-try {
-  const binary = fs.readFileSync(wasmPath);
-  const module = new WebAssembly.Module(binary);
-  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?.();
-}
+instantiate(imports)
+  .then((instance) => {
+    instance.exports.start?.();
+    // Add extra startup logic here when needed.
+  })
+  .catch((error) => {
+    throw new Error("Failed to run bindings module: " + String(error));
+  });
 `;
 }