as-test 1.2.0 → 1.3.0

package/bin/commands/build-core.js

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync, readFileSync } from "fs";
+import { INTERNAL_FEATURE_NAMES, normalizeFeatureName } from "../types.js";
 import { glob } from "glob";
 import chalk from "chalk";
 import { spawn } from "child_process";
@@ -67,6 +68,7 @@ export async function build(
     a.localeCompare(b),
   );
   await assertNoArtifactCollisions(sourceInputPatterns);
+  warnOnUnknownModeReferences(inputFiles, loadedConfig.modes ?? {});
   const coverageEnabled = resolveCoverageEnabled(
     config.coverage,
     featureToggles.coverage,
@@ -75,6 +77,7 @@ export async function build(
     ...mode.env,
     ...config.buildOptions.env,
     AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    AS_TEST_MODE_NAME: modeName ?? "default",
   };
   if (
     !resolvedConfig &&
@@ -259,6 +262,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 +277,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,
@@ -570,7 +697,8 @@ function getBuildStdout(error) {
 }
 function getDefaultBuildArgs(config, featureToggles) {
   const buildArgs = [];
-  const tryAsEnabled = resolveTryAsEnabled(featureToggles.tryAs);
+  const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
+  const tryAsEnabled = resolveTryAsEnabled(effectiveFeatures.has("try-as"));
   buildArgs.push("--transform", "as-test/transform");
   if (
     resolveProjectModule("json-as/transform") &&
@@ -587,6 +715,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" ||
@@ -685,16 +817,29 @@ function transformsContainJsonAs(value) {
   }
   return false;
 }
-function resolveTryAsEnabled(override) {
-  const installed = hasTryAsRuntime();
-  if (override === false) return false;
-  if (override === true && !installed) {
+function resolveEffectiveFeatures(config, featureToggles) {
+  const effective = new Set();
+  for (const name of config.features) {
+    effective.add(normalizeFeatureName(name));
+  }
+  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);
+  }
+  effective.delete("");
+  return effective;
+}
+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;

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

package/bin/commands/init-core.js

@@ -7,6 +7,12 @@ import { getCliVersion } from "../util.js";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 const TARGETS = ["wasi", "bindings", "web"];
 const EXAMPLE_MODES = ["minimal", "full", "none"];
+const FEATURE_KEYS = ["coverage", "tryAs"];
+const FEATURE_LABELS = {
+  coverage: "coverage (runtime coverage points + report)",
+  tryAs:
+    "try-as (try/catch/finally + toThrow assertions + throwable rewriting)",
+};
 export async function init(rawArgs) {
   const options = parseInitArgs(rawArgs);
   const rl = options.yes
@@ -23,6 +29,10 @@ export async function init(rawArgs) {
           target: options.target ?? "wasi",
           example: options.example ?? "minimal",
           fuzzExample: options.fuzzExample ?? false,
+          features: resolveFeatures(options.features, {
+            coverage: false,
+            tryAs: false,
+          }),
           installDependenciesNow: options.install ?? false,
         }
       : await runInteractiveOnboarding(options, rl);
@@ -35,6 +45,7 @@ export async function init(rawArgs) {
       answers.target,
       answers.example,
       answers.fuzzExample,
+      answers.features,
       answers.installDependenciesNow,
     );
     if (!options.yes) {
@@ -49,6 +60,7 @@ export async function init(rawArgs) {
       answers.target,
       answers.example,
       answers.fuzzExample,
+      answers.features,
       options.force,
     );
     printSummary(summary);
@@ -67,6 +79,7 @@ export async function init(rawArgs) {
 }
 function parseInitArgs(rawArgs) {
   const options = {
+    features: {},
     yes: false,
     force: false,
     dir: ".",
@@ -95,6 +108,30 @@ function parseInitArgs(rawArgs) {
       options.fuzzExample = false;
       continue;
     }
+    if (arg == "--enable" || arg == "--disable") {
+      const next = rawArgs[i + 1];
+      if (!next || next.startsWith("-")) {
+        throw new Error(`${arg} requires a value: coverage|try-as`);
+      }
+      for (const name of splitInitFeatureList(next)) {
+        applyInitFeatureToggle(options.features, name, arg == "--enable");
+      }
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
+      const eq = arg.indexOf("=");
+      const flag = arg.slice(0, eq);
+      const value = arg.slice(eq + 1);
+      const names = splitInitFeatureList(value);
+      if (!names.length) {
+        throw new Error(`${flag} requires a value: coverage|try-as`);
+      }
+      for (const name of names) {
+        applyInitFeatureToggle(options.features, name, flag == "--enable");
+      }
+      continue;
+    }
     if (arg == "--target") {
       const next = rawArgs[i + 1];
       if (next && !next.startsWith("-")) {
@@ -158,11 +195,37 @@ function parseInitArgs(rawArgs) {
   }
   if (positional.length > 0) {
     throw new Error(
-      `Unknown init argument(s): ${positional.join(", ")}. Usage: init [dir] [--target wasi|bindings|web] [--example minimal|full|none] [--fuzz-example|--no-fuzz-example] [--install] [--yes] [--force] [--dir <path>]`,
+      `Unknown init argument(s): ${positional.join(", ")}. Usage: init [dir] [--target wasi|bindings|web] [--example minimal|full|none] [--fuzz-example|--no-fuzz-example] [--enable coverage|try-as] [--disable coverage|try-as] [--install] [--yes] [--force] [--dir <path>]`,
     );
   }
   return options;
 }
+function splitInitFeatureList(value) {
+  return value
+    .split(",")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+function applyInitFeatureToggle(out, rawFeature, enabled) {
+  const key = rawFeature.trim().toLowerCase();
+  if (key == "coverage") {
+    out.coverage = enabled;
+    return;
+  }
+  if (key == "try-as" || key == "try_as" || key == "tryas") {
+    out.tryAs = enabled;
+    return;
+  }
+  throw new Error(
+    `unknown feature "${rawFeature}". Supported features: coverage, try-as`,
+  );
+}
+function resolveFeatures(overrides, defaults) {
+  return {
+    coverage: overrides.coverage ?? defaults.coverage,
+    tryAs: overrides.tryAs ?? defaults.tryAs,
+  };
+}
 async function runInteractiveOnboarding(options, face) {
   printOnboardingIntro();
   const acknowledged = await askYesNo(
@@ -231,6 +294,25 @@ async function runInteractiveOnboarding(options, face) {
   if (options.target || onboardingMode == "quick") {
     printPromptAndSelectionLine("Build target", target);
   }
+  const featureDefaults = { coverage: false, tryAs: false };
+  const explicitFeatures =
+    options.features.coverage !== undefined ||
+    options.features.tryAs !== undefined;
+  const features =
+    explicitFeatures || onboardingMode == "quick"
+      ? resolveFeatures(options.features, featureDefaults)
+      : await askMultiToggle(
+          "Features (↑/↓ to move, space to toggle, enter to confirm)",
+          FEATURE_KEYS.map((key) => ({
+            value: key,
+            label: FEATURE_LABELS[key],
+          })),
+          face,
+          resolveFeatures(options.features, featureDefaults),
+        );
+  if (explicitFeatures || onboardingMode == "quick") {
+    printPromptAndSelectionLine("Features", formatFeatureSelection(features));
+  }
   const example =
     options.example ??
     (onboardingMode == "quick"
@@ -275,9 +357,16 @@ async function runInteractiveOnboarding(options, face) {
     target,
     example,
     fuzzExample,
+    features,
     installDependenciesNow,
   };
 }
+function formatFeatureSelection(features) {
+  const labels = [];
+  if (features.coverage) labels.push("coverage");
+  if (features.tryAs) labels.push("try-as");
+  return labels.length ? labels.join(", ") : "none";
+}
 function printOnboardingHeader() {
   // console.log(
   //   chalk.bold.cyan(
@@ -375,7 +464,7 @@ function isTarget(value) {
 function isExampleMode(value) {
   return EXAMPLE_MODES.includes(value);
 }
-function printPlan(root, target, example, fuzzExample, install) {
+function printPlan(root, target, example, fuzzExample, features, install) {
   const displayRoot = () => {
     const rel = path.relative(process.cwd(), root).split(path.sep).join("/");
     if (!rel || rel == ".") return "./";
@@ -483,6 +572,9 @@ function printPlan(root, target, example, fuzzExample, install) {
   console.log(
     "│" + chalk.dim(`  - Fuzzer example: ${fuzzExample ? "yes" : "no"}`),
   );
+  console.log(
+    "│" + chalk.dim(`  - Features: ${formatFeatureSelection(features)}`),
+  );
   console.log("│" + chalk.dim(`  - Directory: ${displayRoot()}`));
   console.log(
     "│" + chalk.dim(`  - Install dependencies: ${install ? "yes" : "no"}`),
@@ -494,7 +586,7 @@ function printPlan(root, target, example, fuzzExample, install) {
   }
   console.log("│");
 }
-function applyInit(root, target, example, fuzzExample, force) {
+function applyInit(root, target, example, fuzzExample, features, force) {
   const summary = {
     created: [],
     updated: [],
@@ -518,13 +610,16 @@ function applyInit(root, target, example, fuzzExample, force) {
     summary,
     "assembly/tsconfig.json",
   );
+  const featuresArray = [];
+  if (features.tryAs) featuresArray.push("try-as");
   const configPath = path.join(root, "as-test.config.json");
   const config = {
     $schema: "node_modules/as-test/as-test.config.schema.json",
     input: ["assembly/__tests__/*.spec.ts"],
     output: ".as-test/",
     config: "none",
-    coverage: false,
+    coverage: features.coverage,
+    features: featuresArray,
     env: {},
     ...(fuzzExample
       ? {
@@ -659,6 +754,9 @@ function applyInit(root, target, example, fuzzExample, force) {
   if (target == "wasi" && !devDependencies["@assemblyscript/wasi-shim"]) {
     devDependencies["@assemblyscript/wasi-shim"] = "^0.1.0";
   }
+  if (features.tryAs && !hasDependency(pkg, "try-as")) {
+    devDependencies["try-as"] = "^1.1.0";
+  }
   if (target == "bindings" && !pkg.type) {
     pkg.type = "module";
   }
@@ -814,6 +912,21 @@ async function askMenuChoice(label, choices, face, fallback) {
   }
   return askMenuChoiceWithArrows(label, choices, face, fallbackValue);
 }
+async function askMultiToggle(label, choices, face, initial) {
+  if (!face) return { ...initial };
+  if (canUseArrowMenu(face)) {
+    return askMultiToggleWithArrows(label, choices, face, initial);
+  }
+  const result = { ...initial };
+  for (const choice of choices) {
+    result[choice.value] = await askYesNo(
+      `${label} — enable ${choice.label}?`,
+      face,
+      initial[choice.value],
+    );
+  }
+  return result;
+}
 async function askYesNo(label, face, fallback) {
   if (!face) return fallback;
   if (canUseArrowMenu(face)) {
@@ -887,7 +1000,7 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
     }
     const totalLineCount = Math.max(lines.length, renderedLineCount);
     for (let i = 0; i < totalLineCount; i++) {
-      process.stdout.write("\x1b[2K");
+      process.stdout.write("\r\x1b[2K");
       if (i < lines.length) {
         process.stdout.write(lines[i]);
       }
@@ -987,6 +1100,141 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
     writeLines(menuLines());
   });
 }
+async function askMultiToggleWithArrows(label, choices, face, initial) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const selected = { ...initial };
+  let cursorIndex = 0;
+  let renderedLineCount = 0;
+  const previousRawMode = Boolean(stdin.isRaw);
+  const lineWidth = Math.max(20, (stdout.columns ?? 80) - 2);
+  const clamp = (value, max) => {
+    if (value.length <= max) return value;
+    if (max <= 1) return value.slice(0, max);
+    return `${value.slice(0, max - 1)}…`;
+  };
+  const titleLine = () =>
+    chalk.bold.blue(`◆  ${clamp(label, Math.max(8, lineWidth - 3))}`);
+  const menuLines = () => {
+    const lines = [titleLine()];
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      const isOn = Boolean(selected[choice.value]);
+      const cursor = i == cursorIndex ? chalk.blue("›") : " ";
+      const marker = isOn ? chalk.blue("●") : chalk.dim("○");
+      const text = clamp(choice.label, Math.max(8, lineWidth - 6));
+      const painted = i == cursorIndex ? chalk.bold(text) : text;
+      lines.push(`│  ${cursor} ${marker} ${painted}`);
+    }
+    lines.push("│");
+    return lines;
+  };
+  const collapsedLines = () => {
+    const enabled = choices
+      .filter((choice) => selected[choice.value])
+      .map((choice) => choice.value);
+    const summary = enabled.length ? enabled.join(", ") : "none";
+    return [`│  ${chalk.gray(clamp(summary, Math.max(8, lineWidth - 4)))}`];
+  };
+  const writeLines = (lines) => {
+    if (renderedLineCount > 0) {
+      process.stdout.write(`\x1b[${renderedLineCount}A`);
+    }
+    const totalLineCount = Math.max(lines.length, renderedLineCount);
+    for (let i = 0; i < totalLineCount; i++) {
+      process.stdout.write("\r\x1b[2K");
+      if (i < lines.length) {
+        process.stdout.write(lines[i]);
+      }
+      process.stdout.write("\n");
+    }
+    renderedLineCount = lines.length;
+  };
+  const collapseInPlace = () => {
+    const lines = collapsedLines();
+    if (renderedLineCount > 0) {
+      process.stdout.write(`\x1b[${renderedLineCount}A`);
+    }
+    const totalLineCount = Math.max(renderedLineCount, lines.length);
+    for (let i = 0; i < totalLineCount; i++) {
+      process.stdout.write("\r\x1b[2K");
+      if (i < lines.length) {
+        process.stdout.write(lines[i]);
+      }
+      process.stdout.write("\n");
+    }
+    const extraLines = totalLineCount - lines.length;
+    if (extraLines > 0) {
+      process.stdout.write(`\x1b[${extraLines}A`);
+    }
+    renderedLineCount = 0;
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      stdin.off("data", onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(previousRawMode);
+      }
+      const isClosed = Boolean(face.closed);
+      if (!isClosed) {
+        try {
+          face.resume();
+        } catch {
+          // noop: readline may already be closed during shutdown/cancel paths.
+        }
+      }
+    };
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      collapseInPlace();
+      cleanup();
+      resolve(selected);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const onData = (chunk) => {
+      const input = typeof chunk == "string" ? chunk : chunk.toString("utf8");
+      if (!input.length) return;
+      if (input == "\u0003") {
+        fail(new Error(chalk.bold.red("◆  Cancelled")));
+        return;
+      }
+      if (input == "\x1b[A" || input == "\x1bOA") {
+        cursorIndex = (cursorIndex - 1 + choices.length) % choices.length;
+        writeLines(menuLines());
+        return;
+      }
+      if (input == "\x1b[B" || input == "\x1bOB") {
+        cursorIndex = (cursorIndex + 1) % choices.length;
+        writeLines(menuLines());
+        return;
+      }
+      if (input == " ") {
+        const key = choices[cursorIndex].value;
+        selected[key] = !selected[key];
+        writeLines(menuLines());
+        return;
+      }
+      if (input == "\r" || input == "\n") {
+        finish();
+        return;
+      }
+    };
+    face.pause();
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("data", onData);
+    writeLines(menuLines());
+  });
+}
 function installDependencies(root) {
   const install = resolveInstallCommand(root);
   console.log(

package/bin/commands/test.js

@@ -11,8 +11,8 @@ export async function executeTestCommand(
   const listFlags = deps.resolveListFlags(rawArgs, "test");
   const featureToggles = deps.resolveFeatureToggles(rawArgs, "test");
   const buildFeatureToggles = {
-    tryAs: featureToggles.tryAs,
     coverage: featureToggles.coverage,
+    featureOverrides: featureToggles.featureOverrides,
   };
   const showCoverageMode = deps.resolveShowCoverageMode(rawArgs, "test");
   const runFlags = {