as-test 1.3.0 → 1.4.0

package/bin/commands/build-core.js

@@ -1,4 +1,6 @@
 import { existsSync, mkdirSync, readFileSync } from "fs";
+import { promises as fsPromises } from "fs";
+import { AsyncLocalStorage } from "async_hooks";
 import { INTERNAL_FEATURE_NAMES, normalizeFeatureName } from "../types.js";
 import { glob } from "glob";
 import chalk from "chalk";
@@ -6,6 +8,7 @@ import { spawn } from "child_process";
 import * as path from "path";
 import {
   createMemoryStream,
+  libraryFiles as ascLibraryFiles,
   main as ascMain,
 } from "assemblyscript/dist/asc.js";
 import {
@@ -20,6 +23,7 @@ import {
 import { persistCrashRecord } from "../crash-store.js";
 import { BuildWorkerPool } from "../build-worker-pool.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+export const buildRecorderStorage = new AsyncLocalStorage();
 export class BuildFailureError extends Error {
   constructor(args) {
     super(args.message);
@@ -82,7 +86,8 @@ export async function build(
   if (
     !resolvedConfig &&
     !process.env.AS_TEST_BUILD_API &&
-    !hasCustomBuildCommand(config)
+    !hasCustomBuildCommand(config) &&
+    !buildRecorderStorage.getStore()
   ) {
     const pool = getSerialBuildWorkerPool();
     for (const file of inputFiles) {
@@ -427,9 +432,25 @@ function getBuildCommand(
       args: [...tokens.slice(1), ...userArgs],
     };
   }
-  const defaultArgs = getDefaultBuildArgs(config, featureToggles);
+  const tryAsAlreadyConfigured =
+    argsDeclareTryAs(userArgs) || asconfigDeclaresTryAs(config.config);
+  const defaultArgs = getDefaultBuildArgs(
+    config,
+    featureToggles,
+    tryAsAlreadyConfigured,
+  );
   const ascInvocation = resolveAscInvocation(pkgRunner);
-  const args = [...ascInvocation.args, file, ...userArgs, ...defaultArgs];
+  // as-test's own transform goes first so CoverageTransform sees the
+  // unmodified user AST. User-supplied `--transform` flags follow it,
+  // then the rest of as-test's default args (config, features, etc.).
+  const args = [
+    ...ascInvocation.args,
+    file,
+    "--transform",
+    "as-test/transform",
+    ...userArgs,
+    ...defaultArgs,
+  ];
   if (config.outDir.length) {
     args.push("-o", outFile);
   }
@@ -578,7 +599,12 @@ function ensureDeps(config) {
   }
 }
 async function buildFile(invocation, env) {
-  if (process.env.AS_TEST_BUILD_API == "1" && invocation.apiArgs?.length) {
+  // The readFile hook only works through the API path. If the watch recorder
+  // is active but env wasn't already set, force the API path so we can
+  // deliver the read stream.
+  const recorderActive = !!buildRecorderStorage.getStore();
+  const wantsApi = recorderActive || process.env.AS_TEST_BUILD_API == "1";
+  if (wantsApi && invocation.apiArgs?.length) {
     await buildFileViaApi(invocation.apiArgs, env);
     return;
   }
@@ -599,8 +625,28 @@ async function buildFileViaApi(args, env) {
   });
   const previousEnv = snapshotEnv();
   applyEnv(env);
+  // asc's `libraryFiles` is a module-global dict that `--lib` flags mutate
+  // by inserting new entries (e.g. wasi-shim files when targeting wasi).
+  // When we call ascMain in-process across multiple modes (which the watch
+  // loop does), those entries leak into later compiles and try to resolve
+  // imports that the next mode's lib path doesn't satisfy. Snapshot the
+  // keys before each call and drop anything new after, so each ascMain sees
+  // the same baseline stdlib.
+  const baselineLibraryKeys = new Set(Object.keys(ascLibraryFiles));
   try {
-    const result = await ascMain(args, { stdout, stderr });
+    const ascOptions = { stdout, stderr };
+    const recorder = buildRecorderStorage.getStore();
+    if (recorder) {
+      const specFile = args[0] ? path.resolve(args[0]) : "";
+      const modeName = process.env.AS_TEST_MODE_NAME;
+      const mode = modeName && modeName !== "default" ? modeName : undefined;
+      if (specFile) {
+        ascOptions.readFile = makeRecordingReadFile((abs) => {
+          recorder.record(mode, specFile, abs);
+        });
+      }
+    }
+    const result = await ascMain(args, ascOptions);
     if (result.error) {
       const error = result.error;
       error.stderr = stderrChunks.join("").trim();
@@ -609,8 +655,27 @@ async function buildFileViaApi(args, env) {
     }
   } finally {
     restoreEnv(previousEnv);
+    for (const key of Object.keys(ascLibraryFiles)) {
+      if (!baselineLibraryKeys.has(key)) {
+        delete ascLibraryFiles[key];
+      }
+    }
   }
 }
+// Mirrors asc's own default readFile (path.resolve(baseDir, filename),
+// readFile utf-8, return null on ENOENT) and records each successful read.
+function makeRecordingReadFile(onFileRead) {
+  return async (filename, baseDir) => {
+    const resolved = path.resolve(baseDir, filename);
+    try {
+      const content = await fsPromises.readFile(resolved, "utf8");
+      onFileRead(resolved);
+      return content;
+    } catch {
+      return null;
+    }
+  };
+}
 async function buildFileViaSpawn(invocation, env) {
   await new Promise((resolve, reject) => {
     const child = spawn(invocation.command, invocation.args, {
@@ -675,6 +740,7 @@ function formatInvocation(invocation) {
     .join(" ");
 }
 export { getBuildCommand, formatInvocation };
+export { argsDeclareTryAs, asconfigDeclaresTryAs };
 function getBuildStderr(error) {
   const err = error;
   const stderr = err?.stderr;
@@ -695,18 +761,24 @@ function getBuildStdout(error) {
   if (stdout instanceof Buffer) return stdout.toString("utf8").trim();
   return "";
 }
-function getDefaultBuildArgs(config, featureToggles) {
+function getDefaultBuildArgs(
+  config,
+  featureToggles,
+  tryAsAlreadyConfigured = false,
+) {
   const buildArgs = [];
   const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
   const tryAsEnabled = resolveTryAsEnabled(effectiveFeatures.has("try-as"));
-  buildArgs.push("--transform", "as-test/transform");
-  if (
-    resolveProjectModule("json-as/transform") &&
-    !userSuppliesJsonAsTransform(config)
-  ) {
-    buildArgs.push("--transform", "json-as/transform");
-  }
-  if (tryAsEnabled) {
+  // `--transform as-test/transform` is appended by `getBuildCommand` at
+  // the front of the user-supplied transforms so coverage instruments
+  // the unmodified user AST.
+  // Auto-inject `--transform try-as/transform` when the `try-as`
+  // feature is on. Unlike json-as, try-as is tightly coupled to as-test
+  // (it powers `toThrow()`), only meaningful when the user explicitly
+  // opts into the feature, and doesn't rewrite arbitrary user code in
+  // ways that surprise consumers — auto-injection keeps the feature
+  // ergonomics intact without the conflict surface json-as exposed.
+  if (tryAsEnabled && !tryAsAlreadyConfigured) {
     buildArgs.push("--transform", "try-as/transform");
   }
   if (config.config && config.config !== "none") {
@@ -749,74 +821,6 @@ function getDefaultBuildArgs(config, featureToggles) {
   }
   return buildArgs;
 }
-// Treats anything whose path contains a "json-as" path component as a
-// user-supplied json-as transform. Matches bare specifiers, subpath specifiers,
-// absolute paths, and ./node_modules paths.
-const JSON_AS_TRANSFORM_PATTERN = /(?:^|[\\/])json-as(?:[\\/@]|$)/;
-function userSuppliesJsonAsTransform(config) {
-  for (const raw of config.buildOptions.args) {
-    if (!raw.length) continue;
-    const tokens = tokenizeCommand(raw);
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i];
-      if (token == "--transform") {
-        const value = tokens[i + 1];
-        if (value && JSON_AS_TRANSFORM_PATTERN.test(value)) return true;
-      } else if (token.startsWith("--transform=")) {
-        const value = token.slice("--transform=".length);
-        if (value && JSON_AS_TRANSFORM_PATTERN.test(value)) return true;
-      }
-    }
-  }
-  if (config.config && config.config !== "none" && existsSync(config.config)) {
-    if (asconfigDeclaresJsonAs(config.config, new Set())) return true;
-  }
-  return false;
-}
-function asconfigDeclaresJsonAs(configFile, seen) {
-  const resolved = path.resolve(configFile);
-  if (seen.has(resolved)) return false;
-  seen.add(resolved);
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(resolved, "utf8"));
-  } catch {
-    return false;
-  }
-  if (!parsed || typeof parsed != "object") return false;
-  const obj = parsed;
-  if (transformsContainJsonAs(obj.options)) return true;
-  if (transformsContainJsonAs(obj)) return true;
-  const targets = obj.targets;
-  if (targets && typeof targets == "object" && !Array.isArray(targets)) {
-    for (const value of Object.values(targets)) {
-      if (transformsContainJsonAs(value)) return true;
-    }
-  }
-  const extendsValue = obj.extends;
-  if (typeof extendsValue == "string" && extendsValue.length) {
-    const parentPath = path.resolve(path.dirname(resolved), extendsValue);
-    if (existsSync(parentPath) && asconfigDeclaresJsonAs(parentPath, seen)) {
-      return true;
-    }
-  }
-  return false;
-}
-function transformsContainJsonAs(value) {
-  if (!value || typeof value != "object") return false;
-  const transform = value.transform;
-  if (typeof transform == "string") {
-    return JSON_AS_TRANSFORM_PATTERN.test(transform);
-  }
-  if (Array.isArray(transform)) {
-    for (const item of transform) {
-      if (typeof item == "string" && JSON_AS_TRANSFORM_PATTERN.test(item)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
 function resolveEffectiveFeatures(config, featureToggles) {
   const effective = new Set();
   for (const name of config.features) {
@@ -853,6 +857,64 @@ function resolveCoverageEnabled(rawCoverage, override) {
 function hasTryAsRuntime() {
   return resolveProjectModule("try-as/package.json") != null;
 }
+const TRY_AS_TRANSFORM_RE = /(?:^|[\\/])try-as(?:[\\/]|$)/;
+function isTryAsTransformSpec(value) {
+  if (typeof value !== "string") return false;
+  if (value === "try-as") return true;
+  return TRY_AS_TRANSFORM_RE.test(value);
+}
+function argsDeclareTryAs(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--transform" || arg === "-t") {
+      const next = args[i + 1];
+      if (isTryAsTransformSpec(next)) return true;
+    } else if (arg.startsWith("--transform=")) {
+      if (isTryAsTransformSpec(arg.slice("--transform=".length))) return true;
+    }
+  }
+  return false;
+}
+function asconfigDeclaresTryAs(configPath, seen = new Set()) {
+  if (!configPath || configPath === "none") return false;
+  const resolved = path.isAbsolute(configPath)
+    ? configPath
+    : path.resolve(process.cwd(), configPath);
+  if (seen.has(resolved)) return false;
+  seen.add(resolved);
+  if (!existsSync(resolved)) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolved, "utf8"));
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object") return false;
+  const obj = parsed;
+  const options = obj.options;
+  if (options && typeof options === "object") {
+    const transform = options.transform;
+    if (Array.isArray(transform)) {
+      for (const t of transform) {
+        if (isTryAsTransformSpec(t)) return true;
+      }
+    }
+  }
+  const extendsField = obj.extends;
+  const extendsList = Array.isArray(extendsField)
+    ? extendsField
+    : typeof extendsField === "string"
+      ? [extendsField]
+      : [];
+  for (const ext of extendsList) {
+    if (typeof ext !== "string") continue;
+    const extPath = path.isAbsolute(ext)
+      ? ext
+      : path.resolve(path.dirname(resolved), ext);
+    if (asconfigDeclaresTryAs(extPath, seen)) return true;
+  }
+  return false;
+}
 function resolveWasiShim() {
   const resolved = resolveProjectModule(
     "@assemblyscript/wasi-shim/asconfig.json",

package/bin/commands/init-core.js

@@ -745,9 +745,6 @@ function applyInit(root, target, example, fuzzExample, features, force) {
   if (!devDependencies["as-test"]) {
     devDependencies["as-test"] = "^" + getCliVersion();
   }
-  if (!hasDependency(pkg, "json-as")) {
-    devDependencies["json-as"] = "^1.3.5";
-  }
   if (!hasDependency(pkg, "assemblyscript")) {
     devDependencies["assemblyscript"] = "^0.28.9";
   }

package/bin/commands/run-core.js

@@ -9,6 +9,7 @@ import {
   getExec,
   loadConfig,
   resolveArtifactPath,
+  resolveSnapshotPath,
   resolveSpecRelativePath,
   tokenizeCommand,
 } from "../util.js";
@@ -33,12 +34,7 @@ class SnapshotStore {
     this.failed = 0;
     this.warnedMissing = new Set();
     this.specBasename = path.basename(specFile);
-    const dir = path.join(process.cwd(), snapshotDir);
-    const relative = resolveSpecRelativePath(specFile, inputPatterns).replace(
-      /\.ts$/i,
-      ".snap",
-    );
-    this.filePath = path.join(dir, relative);
+    this.filePath = resolveSnapshotPath(specFile, snapshotDir, inputPatterns);
     const sourcePath = existsSync(this.filePath) ? this.filePath : null;
     const loaded = sourcePath
       ? readSnapshotFile(sourcePath, specFile)
@@ -543,7 +539,7 @@ function collectReadableLogs(suites) {
     const suiteAny = suite;
     const logs = Array.isArray(suiteAny.logs) ? suiteAny.logs : [];
     for (const log of logs) {
-      const value = String(log.value ?? log.message ?? "");
+      const value = String(log.text ?? log.value ?? log.message ?? "");
       if (value.length) out.push(value);
     }
     const childSuites = Array.isArray(suiteAny.suites) ? suiteAny.suites : [];
@@ -551,6 +547,133 @@ function collectReadableLogs(suites) {
   }
   return out;
 }
+// Walk a suite tree, accumulating each suite's `log()` output keyed by the
+// describe/test description path it was emitted under.
+function walkSuiteLogs(suites, pathParts, out) {
+  for (const suite of suites) {
+    const suiteAny = suite;
+    const description = String(suiteAny.description ?? "");
+    const nextPath = description.length
+      ? [...pathParts, description]
+      : pathParts;
+    const logs = Array.isArray(suiteAny.logs) ? suiteAny.logs : [];
+    const lines = logs.map((log) =>
+      String(log.text ?? log.value ?? log.message ?? ""),
+    );
+    if (lines.length) out.push({ path: nextPath, lines });
+    const childSuites = Array.isArray(suiteAny.suites) ? suiteAny.suites : [];
+    walkSuiteLogs(childSuites, nextPath, out);
+  }
+}
+// Group every captured log across all file reports into a per-spec tree (one
+// entry per `log()` call). Feeds the process-wide collector that backs the
+// aggregated `latest.log` and the `--show-logs` dump.
+function collectGroupedLogs(reports) {
+  let count = 0;
+  const groups = [];
+  for (const report of reports) {
+    const reportAny = report;
+    const suites = Array.isArray(reportAny.suites) ? reportAny.suites : [];
+    const entries = [];
+    walkSuiteLogs(suites, [], entries);
+    if (!entries.length) continue;
+    for (const entry of entries) count += entry.lines.length;
+    groups.push({ file: String(reportAny.file ?? "unknown"), entries });
+  }
+  return { count, groups };
+}
+// Process-lived collector backing the aggregated `latest.log`. Keyed by spec
+// file, then by mode label, holding that mode's flat list of `log()` lines.
+// Persisting across run() calls lets a multi-mode run accumulate every mode
+// before the file is rendered, so identical output can be de-duplicated.
+const collectedLogsBySpec = new Map();
+// Clear the collector. Useful for watch mode, where each cycle should start
+// fresh rather than accumulate stale specs.
+export function resetCollectedLogs() {
+  collectedLogsBySpec.clear();
+}
+function recordModeLogs(modeLabel, groups) {
+  for (const group of groups) {
+    const lines = [];
+    for (const entry of group.entries) lines.push(...entry.lines);
+    if (!lines.length) continue;
+    let byMode = collectedLogsBySpec.get(group.file);
+    if (!byMode) {
+      byMode = new Map();
+      collectedLogsBySpec.set(group.file, byMode);
+    }
+    byMode.set(modeLabel, lines);
+  }
+}
+// Render the collected logs as the `latest.log` body. Within a spec, modes that
+// produced byte-identical output are merged into one block tagged with every
+// mode that emitted it:
+//
+//   [LOG] log.spec.ts (node:bindings, node:wasi):
+//
+//   {"a":1}
+//   ...
+//
+// `count` is the number of de-duplicated `log()` calls (one entry per call —
+// stringify escapes newlines, so a call is a single line), not counting the
+// same call again per mode.
+function renderCollectedLogs() {
+  const blocks = [];
+  let count = 0;
+  const specs = [...collectedLogsBySpec.keys()].sort((a, b) =>
+    a.localeCompare(b),
+  );
+  for (const spec of specs) {
+    const byMode = collectedLogsBySpec.get(spec);
+    // Group modes by identical content so duplicate output collapses into one
+    // block; `calls` is that block's log() count, tallied once regardless of
+    // how many modes produced it.
+    const byContent = new Map();
+    for (const [mode, lines] of byMode) {
+      const content = lines.join("\n");
+      const existing = byContent.get(content);
+      if (existing) existing.modes.push(mode);
+      else byContent.set(content, { modes: [mode], calls: lines.length });
+    }
+    for (const [content, { modes, calls }] of byContent) {
+      const named = modes.filter((mode) => mode !== "default").sort();
+      const suffix = named.length ? ` (${named.join(", ")})` : "";
+      count += calls;
+      blocks.push(
+        `[LOG] ${formatSpecDisplayPath(spec)}${suffix}:\n\n${content}`,
+      );
+    }
+  }
+  return { text: blocks.length ? blocks.join("\n\n") + "\n" : "", count };
+}
+// Render the collector and (re)write the single aggregated `latest.log` at the
+// base (un-mode-qualified) logs dir, so every mode shares one file. Returns the
+// resulting LogSummary. Called by run() after recording its own logs, so the
+// last run() of a multi-mode pass leaves a file covering — and de-duplicating —
+// every mode.
+function flushLatestLog(baseLogsDir) {
+  const rendered = renderCollectedLogs();
+  if (rendered.count <= 0)
+    return { count: 0, file: null, groups: [], text: "" };
+  if (!baseLogsDir || baseLogsDir === "none") {
+    return {
+      count: rendered.count,
+      file: null,
+      groups: [],
+      text: rendered.text,
+    };
+  }
+  const logRoot = path.join(process.cwd(), baseLogsDir);
+  if (!existsSync(logRoot)) mkdirSync(logRoot, { recursive: true });
+  const latestLogPath = path.join(logRoot, "latest.log");
+  writeFileSync(latestLogPath, rendered.text);
+  return {
+    count: rendered.count,
+    file: path.relative(process.cwd(), latestLogPath) || latestLogPath,
+    groups: [],
+    text: rendered.text,
+  };
+}
 export async function run(
   flags = {},
   configPath = DEFAULT_CONFIG_PATH,
@@ -766,6 +889,7 @@ export async function run(
   } finally {
     await ownedWebSession?.close();
   }
+  const groupedLogs = collectGroupedLogs(reports);
   if (config.logs && config.logs != "none") {
     const logRoot = path.join(process.cwd(), config.logs);
     if (!existsSync(logRoot)) {
@@ -786,6 +910,14 @@ export async function run(
       );
     }
   }
+  // Record this run's logs (tagged with its mode) into the process-wide
+  // collector, then rewrite the single aggregated `latest.log` covering every
+  // mode seen so far. The collector persists across run() calls, so the last
+  // run() of a multi-mode pass produces the complete, de-duplicated file. The
+  // file lives at the base (un-mode-qualified) logs dir — `loadedConfig.logs`
+  // before `applyMode` appended the per-mode subdirectory.
+  recordModeLogs(options.modeName ?? "default", groupedLogs.groups);
+  const logSummary = flushLatestLog(loadedConfig.logs);
   const stats = collectRunStats(reports);
   if (options.fileSummaryTotal != undefined) {
     applyConfiguredFileTotalToStats(stats, options.fileSummaryTotal);
@@ -824,6 +956,8 @@ export async function run(
       showCoverage,
       showCoverageAll: Boolean(flags.showCoverageAll),
       verbose: Boolean(flags.verbose),
+      showLogs: Boolean(flags.showLogs),
+      logSummary,
       buildTime,
       snapshotSummary,
       coverageSummary,
@@ -849,6 +983,7 @@ export async function run(
     snapshotSummary,
     coverageSummary,
     reports,
+    logSummary,
   };
 }
 function applyConfiguredFileTotalToStats(stats, fileSummaryTotal) {
@@ -2593,10 +2728,27 @@ function readFileReport(stats, fileReport) {
   const buildCommand = String(fileReportAny.buildCommand ?? "");
   let fileVerdict = "none";
   for (const suite of suites) {
-    fileVerdict = mergeVerdict(
-      fileVerdict,
-      readSuite(stats, suite, file, modeName, runCommand, buildCommand),
+    const suiteVerdict = readSuite(
+      stats,
+      suite,
+      file,
+      modeName,
+      runCommand,
+      buildCommand,
     );
+    fileVerdict = mergeVerdict(fileVerdict, suiteVerdict);
+    // Record each failed top-level suite once. The failure summary recurses into
+    // it to find every failed assertion (so nested failures aren't pushed again,
+    // and a top-level it()/test() failure is captured too).
+    if (suiteVerdict == "fail") {
+      stats.failedEntries.push({
+        ...suite,
+        file,
+        modeName,
+        runCommand,
+        buildCommand,
+      });
+    }
   }
   if (fileVerdict == "fail") {
     stats.failedFiles++;
@@ -2608,7 +2760,6 @@ function readFileReport(stats, fileReport) {
 }
 function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
   const suiteAny = suite;
-  const kind = String(suiteAny.kind ?? "");
   let verdict = normalizeVerdict(suiteAny.verdict);
   const time = suiteAny.time;
   const start = Number(time?.start ?? 0);
@@ -2633,27 +2784,11 @@ function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
       stats.skippedTests++;
     }
   }
-  if (isTestCaseSuiteKind(kind)) {
-    if (!subSuites.length && !tests.length) {
-      if (verdict == "fail") {
-        stats.failedTests++;
-      } else if (verdict == "ok") {
-        stats.passedTests++;
-      } else if (verdict == "skip") {
-        stats.skippedTests++;
-      }
-    }
-    return verdict;
-  }
+  // Every grouping block — describe, test, it, only and their skip variants —
+  // is a suite; the expect() assertions counted above are the tests. (Failed
+  // entries for the summary are collected per top-level suite in readFileReport.)
   if (verdict == "fail") {
     stats.failedSuites++;
-    stats.failedEntries.push({
-      ...suiteAny,
-      file,
-      modeName,
-      runCommand,
-      buildCommand,
-    });
   } else if (verdict == "ok") {
     stats.passedSuites++;
   } else {
@@ -2661,17 +2796,6 @@ function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
   }
   return verdict;
 }
-function isTestCaseSuiteKind(kind) {
-  return (
-    kind == "test" ||
-    kind == "it" ||
-    kind == "only" ||
-    kind == "xtest" ||
-    kind == "xit" ||
-    kind == "xonly" ||
-    kind == "todo"
-  );
-}
 function normalizeVerdict(value) {
   const verdict = String(value ?? "none");
   if (verdict == "fail") return "fail";

package/bin/commands/run.js

@@ -1,4 +1,4 @@
-export { createRunReporter, run } from "./run-core.js";
+export { createRunReporter, resetCollectedLogs, run } from "./run-core.js";
 export async function executeRunCommand(
   rawArgs,
   flags,
@@ -19,6 +19,7 @@ export async function executeRunCommand(
     showCoverage: showCoverageMode != undefined,
     showCoverageAll: showCoverageMode == "all",
     verbose: flags.includes("--verbose"),
+    showLogs: flags.includes("--show-logs"),
     ...deps.resolveParallelJobs(rawArgs, "run"),
     coverage: featureToggles.coverage,
     browser: deps.resolveBrowserOverride(rawArgs, "run"),

package/bin/commands/test.js

@@ -23,11 +23,12 @@ export async function executeTestCommand(
     showCoverage: showCoverageMode != undefined,
     showCoverageAll: showCoverageMode == "all",
     verbose: flags.includes("--verbose"),
+    showLogs: flags.includes("--show-logs"),
     ...deps.resolveParallelJobs(rawArgs, "test"),
     coverage: featureToggles.coverage,
     browser: deps.resolveBrowserOverride(rawArgs, "test"),
     reporterPath: deps.resolveReporterOverride(rawArgs, "test"),
-    watch: flags.includes("--watch"),
+    watch: flags.includes("--watch") || flags.includes("-w"),
   };
   const fuzzEnabled = flags.includes("--fuzz");
   const fuzzOverrides = deps.resolveFuzzOverrides(rawArgs, "test");