as-test 1.2.0 → 1.4.0

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({

package/bin/commands/build-core.js

@@ -1,10 +1,14 @@
 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";
 import { spawn } from "child_process";
 import * as path from "path";
 import {
   createMemoryStream,
+  libraryFiles as ascLibraryFiles,
   main as ascMain,
 } from "assemblyscript/dist/asc.js";
 import {
@@ -19,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);
@@ -67,6 +72,7 @@ export async function build(
     a.localeCompare(b),
   );
   await assertNoArtifactCollisions(sourceInputPatterns);
+  warnOnUnknownModeReferences(inputFiles, loadedConfig.modes ?? {});
   const coverageEnabled = resolveCoverageEnabled(
     config.coverage,
     featureToggles.coverage,
@@ -75,11 +81,13 @@ export async function build(
     ...mode.env,
     ...config.buildOptions.env,
     AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    AS_TEST_MODE_NAME: modeName ?? "default",
   };
   if (
     !resolvedConfig &&
     !process.env.AS_TEST_BUILD_API &&
-    !hasCustomBuildCommand(config)
+    !hasCustomBuildCommand(config) &&
+    !buildRecorderStorage.getStore()
   ) {
     const pool = getSerialBuildWorkerPool();
     for (const file of inputFiles) {
@@ -259,6 +267,7 @@ export async function getBuildReuseInfo(
     ...mode.env,
     ...config.buildOptions.env,
     AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    AS_TEST_MODE_NAME: modeName ?? "default",
   };
   return {
     signature: JSON.stringify({
@@ -273,6 +282,129 @@ export async function getBuildReuseInfo(
 function hasCustomBuildCommand(config) {
   return !!config.buildOptions.cmd.trim().length;
 }
+// Scans input spec files for `mode([...], fn)` calls whose entries reference
+// mode names not present in the configured set. Collects all (file, name)
+// hits and prints a single formatted block to stdout. The implicit "default"
+// name is only valid when no configured mode has `default: true` — otherwise
+// a named mode always runs and `AS_TEST_MODE_NAME` is never literal "default".
+const MODE_CALL_RE = /\bmode\s*\(\s*\[([^\]]*)\]/g;
+const MODE_STRING_RE = /["']([^"']*)["']/g;
+const STRIP_COMMENTS_RE = /\/\*[\s\S]*?\*\/|\/\/.*$/gm;
+const reportedModeWarnings = new Set();
+const pendingModeWarningsByFile = new Map();
+// Scans input spec files for `mode([...], fn)` calls whose entries reference
+// mode names not present in the configured set, and buffers them for later
+// printing via flushModeWarnings(). Called as early as possible (before the
+// reporter starts streaming progress). De-duplicates across invocations.
+export function warnOnUnknownModeReferences(files, configuredModes) {
+  const modeEntries = Object.entries(configuredModes ?? {});
+  const fallsBackToImplicitDefault =
+    modeEntries.length === 0 ||
+    modeEntries.every(([, mode]) => mode?.default === false);
+  const knownModes = new Set(modeEntries.map(([name]) => name));
+  if (fallsBackToImplicitDefault) knownModes.add("default");
+  const knownList = [...knownModes].sort();
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    text = text.replace(STRIP_COMMENTS_RE, "");
+    for (const callMatch of text.matchAll(MODE_CALL_RE)) {
+      const arrayContents = callMatch[1] ?? "";
+      for (const strMatch of arrayContents.matchAll(MODE_STRING_RE)) {
+        let value = strMatch[1] ?? "";
+        if (value.length === 0) continue;
+        if (value.charCodeAt(0) === 33 /* '!' */) value = value.slice(1);
+        if (value.length === 0) continue;
+        if (knownModes.has(value)) continue;
+        const key = `${file}\x1f${value}`;
+        if (reportedModeWarnings.has(key)) continue;
+        reportedModeWarnings.add(key);
+        const warning = {
+          name: value,
+          suggestion: closestKnownMode(value, knownList),
+        };
+        const list = pendingModeWarningsByFile.get(file);
+        if (list) list.push(warning);
+        else pendingModeWarningsByFile.set(file, [warning]);
+      }
+    }
+  }
+}
+// Drains buffered mode warnings. When `showAll` is true, prints the full
+// per-warning block; otherwise prints a one-line summary that tells the user
+// to re-run with `--show-warnings`. No-op when there are no warnings.
+export function flushModeWarnings(showAll) {
+  if (pendingModeWarningsByFile.size === 0) return;
+  const hits = [];
+  for (const [file, list] of pendingModeWarningsByFile) {
+    for (const w of list) {
+      hits.push({ file, name: w.name, suggestion: w.suggestion });
+    }
+  }
+  pendingModeWarningsByFile.clear();
+  if (hits.length === 0) return;
+  if (!showAll) {
+    const count = hits.length;
+    const noun = count === 1 ? "warning" : "warnings";
+    process.stdout.write(
+      `\nFound ${chalk.yellow.bold(count)} ${noun}. Run with ${chalk.dim("--show-warnings")} to view.\n`,
+    );
+    return;
+  }
+  const lines = [chalk.yellow.bold("WARNINGS:")];
+  for (const hit of hits) {
+    let line = ` - unknown mode reference ${chalk.bold(`"${hit.name}"`)} in ${chalk.dim(hit.file)}`;
+    if (hit.suggestion) {
+      line += ` - did you mean ${chalk.cyan(`"${hit.suggestion}"`)}?`;
+    }
+    lines.push(line);
+  }
+  process.stdout.write("\n" + lines.join("\n") + "\n");
+}
+// Returns the configured mode whose Levenshtein distance to `name` is below
+// a small threshold (proportional to the longer string's length). Returns
+// null when nothing's close enough — avoids suggesting wildly different names.
+function closestKnownMode(name, candidates) {
+  let best = null;
+  let bestDist = Infinity;
+  for (const candidate of candidates) {
+    const d = levenshtein(name, candidate);
+    const threshold = Math.max(
+      2,
+      Math.floor(Math.max(name.length, candidate.length) * 0.4),
+    );
+    if (d < bestDist && d <= threshold) {
+      bestDist = d;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      const del = prev[j] + 1;
+      const ins = curr[j - 1] + 1;
+      const sub = prev[j - 1] + cost;
+      curr[j] = Math.min(del, ins, sub);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
 function getBuildCommand(
   config,
   pkgRunner,
@@ -300,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);
   }
@@ -451,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;
   }
@@ -472,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();
@@ -482,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, {
@@ -548,6 +740,7 @@ function formatInvocation(invocation) {
     .join(" ");
 }
 export { getBuildCommand, formatInvocation };
+export { argsDeclareTryAs, asconfigDeclaresTryAs };
 function getBuildStderr(error) {
   const err = error;
   const stderr = err?.stderr;
@@ -568,17 +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 tryAsEnabled = resolveTryAsEnabled(featureToggles.tryAs);
-  buildArgs.push("--transform", "as-test/transform");
-  if (
-    resolveProjectModule("json-as/transform") &&
-    !userSuppliesJsonAsTransform(config)
-  ) {
-    buildArgs.push("--transform", "json-as/transform");
-  }
-  if (tryAsEnabled) {
+  const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
+  const tryAsEnabled = resolveTryAsEnabled(effectiveFeatures.has("try-as"));
+  // `--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") {
@@ -587,6 +787,10 @@ function getDefaultBuildArgs(config, featureToggles) {
   if (tryAsEnabled) {
     buildArgs.push("--use", "AS_TEST_TRY_AS=1");
   }
+  for (const feature of effectiveFeatures) {
+    if (INTERNAL_FEATURE_NAMES.has(feature)) continue;
+    buildArgs.push("--enable", feature);
+  }
   // Should also strip any bindings-enabling from asconfig
   if (
     config.buildOptions.target == "bindings" ||
@@ -617,84 +821,29 @@ 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;
-      }
-    }
+function resolveEffectiveFeatures(config, featureToggles) {
+  const effective = new Set();
+  for (const name of config.features) {
+    effective.add(normalizeFeatureName(name));
   }
-  if (config.config && config.config !== "none" && existsSync(config.config)) {
-    if (asconfigDeclaresJsonAs(config.config, new Set())) return true;
+  const overrides = featureToggles.featureOverrides ?? {};
+  for (const [name, enabled] of Object.entries(overrides)) {
+    const key = normalizeFeatureName(name);
+    if (!key.length) continue;
+    if (enabled) effective.add(key);
+    else effective.delete(key);
   }
-  return false;
+  effective.delete("");
+  return effective;
 }
-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 resolveTryAsEnabled(override) {
-  const installed = hasTryAsRuntime();
-  if (override === false) return false;
-  if (override === true && !installed) {
+function resolveTryAsEnabled(enabled) {
+  if (!enabled) return false;
+  if (!hasTryAsRuntime()) {
     throw new Error(
       'try-as feature was enabled, but package "try-as" is not installed',
     );
   }
-  if (override === true) return true;
-  return false;
+  return true;
 }
 function resolveCoverageEnabled(rawCoverage, override) {
   if (override != undefined) return override;
@@ -708,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/build.js

@@ -5,6 +5,8 @@ export {
   formatInvocation,
   getBuildInvocationPreview,
   getBuildReuseInfo,
+  warnOnUnknownModeReferences,
+  flushModeWarnings,
 } from "./build-core.js";
 export async function executeBuildCommand(
   rawArgs,
@@ -17,8 +19,8 @@ export async function executeBuildCommand(
   const featureToggles = deps.resolveFeatureToggles(rawArgs, "build");
   const parallel = deps.resolveBuildParallelJobs(rawArgs);
   const buildFeatureToggles = {
-    tryAs: featureToggles.tryAs,
     coverage: featureToggles.coverage,
+    featureOverrides: featureToggles.featureOverrides,
   };
   const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
   if (listFlags.list || listFlags.listModes) {