@piagent/platform 1.6.1 → 1.7.1

package/packages/piagent-core/extensions/acceptance-executable-evidence.js

@@ -1,3 +1,7 @@
+import { assertionCarrierBindings, testRunnerBindings, importedCallableBindingIsStable, assertionCarrierIsStable, TEST_RUNNER_EXPORT_KINDS } from "./acceptance-test-bindings.js";
+import { INVALID_DATE_CONSTRUCTION, tupleRegistrationIsClosed } from "./acceptance-tuple-shapes.js";
+import { browserWindowReferencesAreLocal, directPrimitiveArgument } from "./acceptance-local-binding.js";
+
 const ERROR_CONSTRUCTORS = ["typeerror", "rangeerror", "syntaxerror", "referenceerror", "urierror", "evalerror", "aggregateerror", "error"];
 
 function uniqueStrings(values) {
@@ -8,60 +12,15 @@ function escapeRegex(value) {
   return String(value ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function assertionCarrierBindings(testText) {
-  const bindings = [];
-  const add = (name, start, end) => {
-    if (name) bindings.push({ name: name.toLowerCase(), start, end });
-  };
-  for (const match of testText.matchAll(/\bimport\s+([a-z_$][a-z0-9_$]*)\s+from\s+__pi_node_assert_module_literal__\s*;?/gi)) {
-    add(match[1], match.index, match.index + match[0].length);
-  }
-  for (const match of testText.matchAll(/\bimport\s+\*\s+as\s+([a-z_$][a-z0-9_$]*)\s+from\s+__pi_node_assert_module_literal__\s*;?/gi)) {
-    add(match[1], match.index, match.index + match[0].length);
-  }
-  for (const match of testText.matchAll(/\bimport\s*\{([^}]{1,500})\}\s*from\s+__pi_node_assert_module_literal__\s*;?/gi)) {
-    for (const item of match[1].split(",")) {
-      const strict = item.trim().match(/^strict(?:\s+as\s+([a-z_$][a-z0-9_$]*))?$/i);
-      if (strict) add(strict[1] ?? "strict", match.index, match.index + match[0].length);
-    }
-  }
-  for (const match of testText.matchAll(/\bconst\s+([a-z_$][a-z0-9_$]*)\s*=\s*require\s*\(\s*__pi_node_assert_module_literal__\s*\)(?:\s*\.\s*strict)?\s*;?/gi)) {
-    add(match[1], match.index, match.index + match[0].length);
-  }
-  for (const match of testText.matchAll(/\bconst\s*\{\s*strict\s*:\s*([a-z_$][a-z0-9_$]*)\s*\}\s*=\s*require\s*\(\s*__pi_node_assert_module_literal__\s*\)\s*;?/gi)) {
-    add(match[1], match.index, match.index + match[0].length);
-  }
-  return bindings.slice(0, 8);
-}
-
-function assertionCarrierIsStable(testText, binding) {
-  const escaped = escapeRegex(binding.name);
-  const withoutDeclaration = `${testText.slice(0, binding.start)}${" ".repeat(binding.end - binding.start)}${testText.slice(binding.end)}`;
-  if (assertionCarrierBindings(testText).filter((candidate) => candidate.name === binding.name).length !== 1) return false;
-  if (new RegExp(`\\b(?:const|let|var|function|class)\\s+${escaped}\\b|\\bfunction\\b[^({]{0,200}\\([^)]*\\b${escaped}\\b|\\bcatch\\s*\\([^)]*\\b${escaped}\\b|(?:\\([^)]*\\b${escaped}\\b[^)]*\\)|\\b${escaped})\\s*=>`, "i").test(withoutDeclaration)) return false;
-  if (new RegExp(`(?<![.$a-z0-9_])${escaped}\\b\\s*(?:(?<![=!<>])=(?!=|>)|\\+\\+|--|[+*/%&|^-]=)|(?:\\+\\+|--)\\s*\\b${escaped}\\b`, "i").test(withoutDeclaration)) return false;
-  if (new RegExp(`\\b(?:const|let|var)\\s+[a-z_$][a-z0-9_$]*\\s*=\\s*${escaped}\\b|\\b(?:const|let|var)\\s*\\{[^}\\n]{0,500}\\}\\s*=\\s*${escaped}\\b`, "i").test(withoutDeclaration)) return false;
-  if (new RegExp(`(?<![.$a-z0-9_])[a-z_$][a-z0-9_$]*\\s*(?<![=!<>])=(?!=|>)\\s*${escaped}\\b`, "i").test(withoutDeclaration)) return false;
-  const member = `${escaped}\\s*(?:\\.\\s*[a-z_$][a-z0-9_$]*|\\[[^\\]]{1,300}\\])`;
-  if (new RegExp(`\\b${member}\\s*(?:=|\\+\\+|--|[+*/%&|^-]=|(?:&&|\\|\\||\\?\\?)=)|(?:\\+\\+|--)\\s*\\b${member}|\\bdelete\\s+${escaped}\\s*(?:\\.|\\[)|\\b${escaped}\\s*\\.\\s*__(?:definegetter|definesetter)__\\s*\\(`, "i").test(withoutDeclaration)) return false;
-  if (new RegExp(`(?:\\{[^}\\n]{0,500}\\b${member}[^}\\n]{0,500}\\}|\\[[^\\]\\n]{0,500}\\b${member}[^\\]\\n]{0,500}\\])\\s*=|\\bfor(?:\\s+await)?\\s*\\(\\s*(?:${member}|\\{[^}\\n]{0,500}\\b${member}[^}\\n]{0,500}\\}|\\[[^\\]\\n]{0,500}\\b${member}[^\\]\\n]{0,500}\\])\\s+(?:of|in)\\b`, "i").test(withoutDeclaration)) return false;
-  if (new RegExp(`\\b(?:object|reflect)\\s*\\.\\s*[a-z_$][a-z0-9_$]*\\s*\\(\\s*${escaped}\\s*[,)]|\\b[a-z_$][a-z0-9_$.]*\\s*\\(\\s*${escaped}\\s*[,)]`, "i").test(withoutDeclaration)) return false;
-  for (const match of withoutDeclaration.matchAll(new RegExp(`\\b${escaped}\\b`, "gi"))) {
-    const suffix = withoutDeclaration.slice(match.index + match[0].length);
-    if (/^\s*\(/.test(suffix) || /^\s*\.\s*[a-z_$][a-z0-9_$]*\s*\(/i.test(suffix)) continue;
-    return false;
-  }
-  return true;
-}
-
 function assertionEvidenceFileSupported(testText) {
-  if (/\\|__pi_(?:code_generation|module_loader)_module_literal__|\b(?:eval|createrequire)\b|\b(?:process|globalthis|global|window|self|this)\b|\bmodule\s*\.\s*(?:require|constructor|_load)\b|\.\s*constructor\b|\bfunction\s*\(|(?:=|[,([])\s*function\b(?!\s+[a-z_$][a-z0-9_$]*\s*\()/i.test(testText)) return false;
+  if (!browserWindowReferencesAreLocal(testText)) return false;
+  if (/\\|__pi_(?:code_generation|module_loader)_module_literal__|\b(?:eval|createrequire)\b|\b(?:process|globalthis|global|self|this)\b|\bmodule\s*\.\s*(?:require|constructor|_load)\b|\.\s*constructor\b|\bfunction\s*\(|(?:=|[,([])\s*function\b(?!\s+[a-z_$][a-z0-9_$]*\s*\()/i.test(testText)) return false;
   if (/\brequire\b(?!\s*\()/i.test(testText)) return false;
   for (const match of testText.matchAll(/\b(?:require|import)\s*\(/gi)) {
     const open = testText.indexOf("(", match.index);
     const end = balancedEnd(testText, open);
     const argument = end === -1 ? "" : testText.slice(open + 1, end - 1).trim();
-    if (!/^__pi_(?:bound_string_\d+|string|node_assert_module)_literal__$/.test(argument)) return false;
+    if (!/^__pi_(?:bound_string_\d+|string|node_assert_module|node_test_module)_literal__$/.test(argument)) return false;
   }
   return true;
 }
@@ -70,6 +29,103 @@ function nodeAssertModuleReferenceCount(testText) {
   return [...testText.matchAll(/__pi_node_assert_module_literal__/g)].length;
 }
 
+export function literalArrayIterationEnvironmentIsStable(testText) {
+  const code = String(testText ?? "");
+  if (/\barray\s*\.\s*prototype\b|\bsymbol\b|\breflect\b|__proto__|\bobject\s*\.\s*(?:get|set|define|assign)/i.test(code)) return false;
+  const intrinsic = "(?:array|symbol)";
+  if (new RegExp(`\\b(?:const|let|var|function|class)\\s+${intrinsic}\\b|\\bimport\\s+(?:\\*\\s+as\\s+)?${intrinsic}\\b|\\bimport\\s*\\{[^}\\n]{0,500}\\bas\\s+${intrinsic}\\b`, "i").test(code)) return false;
+  if (new RegExp(`\\b(?:const|let|var)\\s+(?:\\{[^}\\n]{0,500}\\b${intrinsic}\\b|\\[[^\\]\\n]{0,500}\\b${intrinsic}\\b)|\\b(?:function|catch)\\b[^({]{0,200}\\([^)]*\\b${intrinsic}\\b`, "i").test(code)) return false;
+  if (new RegExp(`(?:\\([^)]*\\b${intrinsic}\\b[^)]*\\)|\\b${intrinsic})\\s*=>|(?<![.$a-z0-9_])${intrinsic}\\s*(?:(?<![=!<>])=(?!=|>)|\\+\\+|--|[+*/%&|^-]=)`, "i").test(code)) return false;
+  return true;
+}
+
+function moduleBackedBindings(code, moduleToken, exportedNames = []) {
+  const names = new Set(), token = escapeRegex(moduleToken);
+  const add = (name) => { if (/^[a-z_$][a-z0-9_$]*$/i.test(name ?? "")) names.add(name.toLowerCase()); };
+  for (const match of code.matchAll(new RegExp(`\\bimport\\s+([a-z_$][a-z0-9_$]*)(?:\\s*,\\s*\\{[^}]{1,500}\\})?\\s+from\\s+${token}\\b`, "gi"))) add(match[1]);
+  for (const match of code.matchAll(new RegExp(`\\bimport\\s+\\*\\s+as\\s+([a-z_$][a-z0-9_$]*)\\s+from\\s+${token}\\b`, "gi"))) add(match[1]);
+  for (const match of code.matchAll(new RegExp(`\\bimport\\s+(?:[a-z_$][a-z0-9_$]*\\s*,\\s*)?\\{([^}]{1,500})\\}\\s*from\\s+${token}\\b`, "gi"))) {
+    for (const raw of match[1].split(",")) {
+      const item = raw.trim().match(/^([a-z_$][a-z0-9_$]*)(?:\s+as\s+([a-z_$][a-z0-9_$]*))?$/i);
+      if (item && exportedNames.includes(item[1].toLowerCase())) add(item[2] ?? item[1]);
+    }
+  }
+  for (const match of code.matchAll(new RegExp(`\\b(?:const|let|var)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*require\\s*\\(\\s*${token}\\s*\\)(?:\\s*\\.\\s*(?:strict|${exportedNames.join("|")}))?\\s*;?`, "gi"))) add(match[1]);
+  for (const match of code.matchAll(new RegExp(`\\b(?:const|let|var)\\s*\\{([^}]{1,500})\\}\\s*=\\s*require\\s*\\(\\s*${token}\\s*\\)`, "gi"))) {
+    for (const raw of match[1].split(",")) {
+      const item = raw.trim().match(/^([a-z_$][a-z0-9_$]*)(?:\s*:\s*([a-z_$][a-z0-9_$]*))?$/i);
+      if (item && exportedNames.includes(item[1].toLowerCase())) add(item[2] ?? item[1]);
+    }
+  }
+  for (let pass = 0; pass < 4; pass += 1) {
+    const priorSize = names.size;
+    for (const name of [...names]) {
+      const backed = `${escapeRegex(name)}(?:\\s*\\.\\s*[a-z_$][a-z0-9_$]*|\\s*\\[[^\\]\\n]{1,300}\\])?`;
+      for (const match of code.matchAll(new RegExp(`\\b(?:const|let|var)\\s+([a-z_$][a-z0-9_$]*)\\s*=\\s*${backed}\\s*(?:;|\\n|$)`, "gi"))) add(match[1]);
+      for (const match of code.matchAll(new RegExp(`(?<![.$a-z0-9_])([a-z_$][a-z0-9_$]*)\\s*=\\s*${backed}\\s*(?:;|\\n|$)`, "gi"))) add(match[1]);
+      for (const match of code.matchAll(new RegExp(`\\b(?:const|let|var)\\s*\\{([^}]{1,500})\\}\\s*=\\s*${escapeRegex(name)}\\b`, "gi"))) {
+        for (const raw of match[1].split(",")) add(raw.trim().match(/^(?:[a-z_$][a-z0-9_$]*\s*:\s*)?([a-z_$][a-z0-9_$]*)$/i)?.[1]);
+      }
+    }
+    if (names.size === priorSize) break;
+  }
+  return [...names];
+}
+
+function withoutModuleBindingDeclarations(code, moduleToken) {
+  const token = escapeRegex(moduleToken), blank = (match) => " ".repeat(match.length);
+  return String(code ?? "")
+    .replace(new RegExp(`\\bimport\\s+[^;\\n]{1,800}?\\s+from\\s+${token}\\s*;?`, "gi"), blank)
+    .replace(new RegExp(`\\b(?:const|let|var)\\s+[^;\\n]{1,800}?=\\s*require\\s*\\(\\s*${token}\\s*\\)[^;\\n]*;?`, "gi"), blank);
+}
+
+function moduleBindingEscapes(code, binding) {
+  // Returning a direct module method call does not return the module binding.
+  // Bare members and bound methods remain escapes; mutation checks still apply.
+  const name = `(?<![.$a-z0-9_])${escapeRegex(binding)}\\b`;
+  if (new RegExp(`\\b(?:const|let|var)\\s+[a-z_$][a-z0-9_$]*\\s*=\\s*(?:${name}|\\{[^}\\n]{0,500}${name}|\\[[^\\]\\n]{0,500}${name})`, "i").test(code)) return true;
+  if (new RegExp(`(?<![=!<>])=(?!=|>)\\s*${name}|\\breturn\\s+${name}|=>\\s*${name}(?!\\s*\\.\\s*[a-z_$][a-z0-9_$]*\\s*\\()|\\.\\.\\.\\s*${name}`, "i").test(code)) return true;
+  if (new RegExp(`(?:\\(|\\{|\\[|,|:)\\s*(?:[a-z_$][a-z0-9_$]*\\s*:\\s*)?${name}\\s*(?:,|\\)|\\}|\\])`, "i").test(code)) return true;
+  return new RegExp(`(?:\\(|,)\\s*${name}\\s*(?:,|\\))`, "i").test(code);
+}
+
+function moduleTargetIsMutated(code, target) {
+  const member = "(?:\\s*\\.\\s*[a-z_$][a-z0-9_$]*|\\s*\\[[^\\]\\n]{1,300}\\])";
+  const lvalue = `(?:${target})(?:${member}){1,4}`;
+  if (new RegExp(`${lvalue}\\s*(?:=(?!=|>)|\\+\\+|--|[+*/%&|^-]=|(?:&&|\\|\\||\\?\\?)=)|(?:\\+\\+|--)\\s*${lvalue}|\\bdelete\\s+${lvalue}`, "i").test(code)) return true;
+  if (new RegExp(`\\b(?:object\\s*\\.\\s*(?:assign|defineproperties|defineproperty|setprototypeof)|reflect\\s*\\.\\s*(?:defineproperty|set|setprototypeof))\\s*\\(\\s*(?:${target})\\s*[,)]`, "i").test(code)) return true;
+  return new RegExp(`(?:${target})\\s*\\.\\s*__(?:definegetter|definesetter)__\\s*\\(`, "i").test(code);
+}
+
+/** Reject corpus-wide mutation of assertion carriers or test registration APIs. */
+export function testProofIntrinsicsAreStable(testText) {
+  const code = String(testText ?? "");
+  if (/__pi_node_process_module_literal__|\bprocess\s*(?:\.|\[)/i.test(code)) return false;
+  if (/\bimport\s+(?:__pi_bound_string_\d+__|__pi_template_literal__)\s*(?=;|\b(?:assert|with)\b|[\r\n]|$)/i.test(code)) return false;
+  if (/__pi_template_literal__/.test(code)
+    && /__pi_node_(?:assert|test)_module_literal__/.test(code)) return false;
+  for (const match of code.matchAll(/\b(?:import|require)\s*\(/gi)) {
+    const open = code.indexOf("(", match.index), end = balancedEnd(code, open);
+    const argument = end === -1 ? "" : code.slice(open + 1, end - 1).trim();
+    if (!/^__pi_(?:bound_string_\d+|node_assert_module|node_process_module|node_test_module)_literal__$/.test(argument)) return false;
+    if (/^__pi_node_(?:assert|test)_module_literal__$/.test(argument) && /^import/i.test(match[0])) return false;
+  }
+  const modules = [
+    { token: "__pi_node_assert_module_literal__", exports: ["default", "strict"] },
+    { token: "__pi_node_test_module_literal__", exports: ["default", ...TEST_RUNNER_EXPORT_KINDS.keys()] }
+  ];
+  for (const module of modules) {
+    const direct = `require\\s*\\(\\s*${module.token}\\s*\\)(?:\\s*\\.\\s*strict)?`;
+    if (moduleTargetIsMutated(code, direct)) return false;
+    const declarationFree = withoutModuleBindingDeclarations(code, module.token);
+    for (const binding of moduleBackedBindings(code, module.token, module.exports)) {
+      if (moduleBindingEscapes(declarationFree, binding)) return false;
+      if (moduleTargetIsMutated(code, `(?<![.$a-z0-9_])${escapeRegex(binding)}\\b`)) return false;
+    }
+  }
+  return true;
+}
+
 function balancedEnd(text, openIndex, opening = "(", closing = ")", ceiling = 8_000) {
   if (text[openIndex] !== opening) return -1;
   let depth = 0;
@@ -106,6 +162,141 @@ function topLevelArgumentRanges(text, openIndex, endIndex) {
 export function evidenceTopLevelArguments(text, openIndex, endIndex) {
   return topLevelArgumentRanges(text, openIndex, endIndex).map((argument) => argument.text);
 }
+function operationArguments(operation, target) {
+  const callable = String(target ?? "").replace(/^\*\./, "");
+  if (!callable) return [];
+  const text = String(operation ?? "");
+  const pattern = new RegExp(`(?:^|[^a-z0-9_$])${escapeRegex(callable)}\\s*\\(`, "gi");
+  for (const match of text.matchAll(pattern)) {
+    const open = text.indexOf("(", match.index + match[0].length - 1);
+    const end = balancedEnd(text, open);
+    if (end !== -1) return topLevelArgumentRanges(text, open, end).map((item) => item.text.trim());
+  }
+  return [];
+}
+
+function literalBooleanTernarySelection(raw) {
+  let value = String(raw ?? "").trim();
+  while (value.startsWith("(") && balancedEnd(value, 0) === value.length) value = value.slice(1, -1).trim();
+  let question = -1, colon = -1, parentheses = 0, brackets = 0, braces = 0, ternaries = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "(") parentheses += 1;
+    else if (value[index] === ")") parentheses -= 1;
+    else if (value[index] === "[") brackets += 1;
+    else if (value[index] === "]") brackets -= 1;
+    else if (value[index] === "{") braces += 1;
+    else if (value[index] === "}") braces -= 1;
+    else if (parentheses === 0 && brackets === 0 && braces === 0 && value[index] === "?") {
+      if (question === -1) question = index;
+      ternaries += 1;
+    } else if (parentheses === 0 && brackets === 0 && braces === 0 && value[index] === ":" && ternaries > 0) {
+      ternaries -= 1;
+      if (ternaries === 0) { colon = index; break; }
+    }
+    if (parentheses < 0 || brackets < 0 || braces < 0) return { kind: "unknown" };
+  }
+  if (question === -1) return { kind: "plain", value };
+  if (colon === -1 || ternaries !== 0) return { kind: "unknown" };
+  const condition = value.slice(0, question).trim();
+  const conditionValue = simpleConstantValue(condition);
+  if (conditionValue === undefined) return { kind: "unknown" };
+  return {
+    kind: "selected",
+    value: conditionValue ? value.slice(question + 1, colon).trim() : value.slice(colon + 1).trim()
+  };
+}
+
+function annotateInvalidArgumentCoverage(assertions) {
+  const proofPartitions = new Set(["fractional", "invalid-calendar-date-string", "invalid-date-object", "invalid-date-string", "missing", "negative", "non-finite-number", "unsafe-integer"]);
+  const directInvalidPartitions = new Set(["invalid-calendar-date-string", "invalid-date-object", "invalid-date-string", "missing", "non-finite-number"]);
+  const argumentPartitions = (raw, collection = false) => {
+    let selected = literalBooleanTernarySelection(raw);
+    if (selected.kind === "unknown") return new Set();
+    while (selected.kind === "selected") {
+      selected = literalBooleanTernarySelection(selected.value);
+      if (selected.kind === "unknown") return new Set();
+    }
+    const value = selected.value;
+    const values = collection && value.startsWith("[") && balancedEnd(value, 0, "[", "]") === value.length
+      ? topLevelArgumentRanges(value, 0, value.length).map((item) => item.text.trim()) : [value];
+    const partitions = new Set();
+    for (const item of values) {
+      if (/^new\s+date\b/i.test(item)) {
+        if (INVALID_DATE_CONSTRUCTION.test(item)) partitions.add("invalid-date-object");
+        continue; // Constructor arguments are not the value passed to the entrypoint.
+      }
+      if (!directPrimitiveArgument(item)) continue;
+      for (const partition of evidencePartitionSignals(item)) if (proofPartitions.has(partition)) partitions.add(partition);
+      if (/^__pi_(?:invalid_(?:calendar_)?date|unparseable_date)_string_literal__$/.test(item)) partitions.add("invalid-date-string");
+      if (item === "__pi_invalid_calendar_date_string_literal__") partitions.add("invalid-calendar-date-string");
+      if (/^(?:number\.)?(?:nan|positive_infinity|negative_infinity|infinity)$/i.test(item)) partitions.add("non-finite-number");
+    }
+    return partitions;
+  };
+  const groups = new Map();
+  for (const assertion of assertions) {
+    if (!new Set(["rejects", "throws"]).has(assertion.mode)) continue;
+    for (const target of assertion.targets) {
+      const argumentsList = operationArguments(assertion.operation, target);
+      if (argumentsList.length === 0) continue;
+      const key = `${target}\u0000${assertion.mode}\u0000${[...assertion.errorClasses].sort().join(",")}`;
+      const entries = groups.get(key) ?? [];
+      entries.push({ assertion, argumentsList });
+      groups.set(key, entries);
+    }
+  }
+  for (const entries of groups.values()) {
+    const required = new Set();
+    const partitionsByIndex = new Map();
+    const addPartitions = (index, values) => {
+      const partitions = partitionsByIndex.get(index) ?? new Set();
+      for (const value of values) if (proofPartitions.has(value)) partitions.add(value);
+      partitionsByIndex.set(index, partitions);
+    };
+    for (const { assertion, argumentsList } of entries) {
+      if (argumentsList.length === 1) required.add(0);
+      for (let index = 0; index < argumentsList.length; index += 1) {
+        const directPartitions = argumentPartitions(argumentsList[index]);
+        if ([...directPartitions].some((partition) => directInvalidPartitions.has(partition))) {
+          required.add(index);
+          addPartitions(index, directPartitions);
+        }
+        for (const binding of assertion.iterationBindings ?? []) {
+          if (!new RegExp(`\\b${escapeRegex(binding.variable)}\\b`, "i").test(argumentsList[index])) continue;
+          required.add(index);
+          if (literalBooleanTernarySelection(argumentsList[index]).value === binding.variable) addPartitions(index, argumentPartitions(binding.literal, true));
+        }
+      }
+    }
+    const maximumArity = Math.max(0, ...entries.map((entry) => entry.argumentsList.length));
+    for (let index = 0; index < maximumArity; index += 1) {
+      const corpora = new Map();
+      for (const { argumentsList } of entries) {
+        if (argumentsList.length !== maximumArity) continue;
+        const fixed = argumentsList.map((value, argumentIndex) => argumentIndex === index ? "__varying__" : value).join("\u0000");
+        const values = corpora.get(fixed) ?? new Set();
+        values.add(argumentsList[index]);
+        corpora.set(fixed, values);
+      }
+      // Three independently asserted values with every other argument fixed
+      // form a bounded invalid-input corpus rather than incidental variation.
+      for (const values of corpora.values()) {
+        if (values.size < 3) continue;
+        required.add(index);
+        for (const value of values) addPartitions(index, argumentPartitions(value));
+      }
+    }
+    for (const { assertion } of entries) {
+      assertion.invalidArgumentIndices = [...new Set([...(assertion.invalidArgumentIndices ?? []), ...required])]
+        .sort((left, right) => left - right);
+      assertion.invalidArgumentPartitions = [...required].sort((left, right) => left - right).map((index) => ({
+        index,
+        partitions: [...(partitionsByIndex.get(index) ?? [])].sort()
+      }));
+    }
+  }
+  return assertions;
+}
 
 function evidenceErrorClasses(text) {
   return ERROR_CONSTRUCTORS.filter((name) => (
@@ -152,8 +343,8 @@ function simpleConstantValue(raw) {
 
 function operationTargets(raw, callableNames) {
   let operation = String(raw ?? "").trim();
-  const arrow = operation.indexOf("=>");
-  if (arrow !== -1) operation = operation.slice(arrow + 2).trim();
+  const arrow = operation.match(/^(?:async\s+)?(?:\([^()]*\)|[a-z_$][a-z0-9_$]*)\s*=>/i);
+  if (arrow) operation = operation.slice(arrow[0].length).trim();
   else if (/^function\b/.test(operation)) operation = operation.slice(operation.indexOf("{")).trim();
   if (operation.startsWith("{") && balancedEnd(operation, 0, "{", "}") === operation.length) operation = operation.slice(1, -1).trim();
   operation = operation.replace(/^(?:return\s+)?(?:await\s+)?/, "").replace(/;\s*$/, "").trim();
@@ -191,7 +382,7 @@ function evidencePartitionSignals(text) {
   if (/\bundefined\b/.test(text)) signals.add("missing");
   if (/__pi_empty_string_literal__/.test(text)) signals.add("empty-string");
   if (/__pi_whitespace_string_literal__/.test(text)) signals.add("whitespace-string");
-  if (/(?:^|[^\w.])-\s*(?:\d+(?:\.\d+)?|infinity)\b/.test(text)) signals.add("negative");
+  if (/(?:^|[^\w.])-\s*(?:\d+(?:\.\d+)?)\b/.test(text)) signals.add("negative");
   if (/(?:^|[^\w.])(?:\d+\.\d+|\.\d+)(?:[^\w.]|$)/.test(text)) signals.add("fractional");
   if (/(?:^|[^\w.])0n?(?:[^\w.]|$)/.test(text)) signals.add("zero");
   if (/\b(?:nan|infinity)\b|number\.(?:positive_|negative_)?infinity/.test(text)) signals.add("non-finite");
@@ -222,6 +413,59 @@ function literalArrayPartitionSignals(literal) {
   return signals;
 }
 
+function constantTupleRows(literal, testText) {
+  const atom = String.raw`(?:undefined|null|true|false|nan|infinity|number\.(?:nan|(?:positive_|negative_)?infinity)|-?(?:\d+(?:\.\d+)?|\.\d+)|__pi_[a-z0-9_]*string_literal__)`;
+  const cell = new RegExp(`^${atom}$`, "i");
+  const elements = (text) => {
+    const values = topLevelArgumentRanges(text, 0, text.length).map((item) => item.text);
+    if (values.at(-1) === "" && /,\s*\]$/.test(text)) values.pop();
+    return values;
+  };
+  const rows = elements(literal);
+  if (rows.length === 0 || rows.length > 24) return undefined;
+  const values = rows.map((row) => boundedNonEmptyArrayLiteral(row)
+    ? elements(row) : []);
+  if (values.some((row) => row.length !== 2 || row.some((value) => !cell.test(value) && !INVALID_DATE_CONSTRUCTION.test(value)))) return undefined;
+  // A literal Date allocation is the only admitted cell call. Its constructor
+  // and the primitive intrinsic values must not be rebound or escape by alias.
+  const intrinsic = "(?:date|number|nan|infinity|undefined)";
+  if (new RegExp(`\\b(?:const|let|var|class|function)\\s+${intrinsic}\\b|\\b(?:import|function|catch)\\b[^;{}]{0,300}\\b${intrinsic}\\b`, "i").test(testText)
+    || new RegExp(`\\b(?:const|let|var)\\s*(?:\\{[^}]{0,500}\\b${intrinsic}\\b|\\[[^\\]]{0,500}\\b${intrinsic}\\b)|(?:\\([^)]*\\b${intrinsic}\\b[^)]*\\)|\\b${intrinsic})\\s*=>`, "i").test(testText)
+    || new RegExp(`\\b${intrinsic}\\b(?:\\s*\\.\\s*[a-z_$][a-z0-9_$]*)?\\s*(?:=(?!=|>)|\\+\\+|--|[+*/%&|^-]=)`, "i").test(testText)) return undefined;
+  for (const match of testText.matchAll(/\b(?:date|number)\b/gi)) {
+    const before = testText.slice(0, match.index), after = testText.slice(match.index + match[0].length);
+    if (match[0].toLowerCase() === "date" && /\bnew\s*$/.test(before) && /^\s*\(/.test(after)) continue;
+    if (/^\s*\.\s*(?:parse|now|utc|isfinite|isnan|isinteger|issafeinteger)\s*\(/i.test(after)) continue;
+    if (/^\s*\.\s*(?:nan|(?:positive_|negative_)?infinity)\b(?!\s*(?:\[|\.|=|\+\+|--))/i.test(after)) continue;
+    return undefined;
+  }
+  return values;
+}
+
+function tupleTargetImportsAreStable(testText, callableNames) {
+  const imports = [...testText.matchAll(/\bimport\s+([^;]{1,800}?)\s+from\s+__pi_[a-z0-9_]+__\s*;?/gi)];
+  return [...callableNames].every((name) => {
+    const root = name.split(".")[0];
+    if (!/^[a-z_$][a-z0-9_$]*$/i.test(root)) return false;
+    const matches = imports.filter((item) => new RegExp(`\\b${escapeRegex(root)}\\b`, "i").test(item[1]));
+    const bindings = matches.map((item) => ({ name: root, start: item.index, end: item.index + item[0].length }));
+    return bindings.length === 1 && importedCallableBindingIsStable(testText, bindings[0], bindings);
+  });
+}
+
+function tupleExpectedErrorClasses(assertion) {
+  const invocation = assertion.match(/^[a-z_$][a-z0-9_$]*\.(?:throws|rejects)\s*\(/i);
+  if (!invocation) return undefined;
+  const open = invocation[0].length - 1, end = balancedEnd(assertion, open);
+  if (end !== assertion.length) return undefined;
+  const args = topLevelArgumentRanges(assertion, open, end).map((item) => item.text);
+  if (args.length !== 2 && args.length !== 3) return undefined;
+  if (args.length === 3 && !/^__pi_(?:[a-z0-9_]*string|error_name_[a-z]+)_literal__$/.test(args[2])) return undefined;
+  const expected = ERROR_CONSTRUCTORS.find((name) => args[1] === name
+    || new RegExp(`^\\{\\s*name\\s*:\\s*__pi_error_name_${name}_literal__\\s*,?\\s*\\}$`).test(args[1]));
+  return expected ? [expected] : undefined;
+}
+
 function assertionHelperDeclarations(testText) {
   const declarations = [];
   for (const match of testText.matchAll(/\bfunction\s+([a-z_$][a-z0-9_$]*)\s*\(([^)]*)\)\s*\{/gi)) {
@@ -265,57 +509,82 @@ function rejectionAssertionHelpers(testText, assertionCarriers) {
 function registrationArgumentsEnabled(argumentsList) {
   if (argumentsList.length <= 2) return true;
   if (argumentsList.length !== 3 || !/^\{[\s\S]{0,800}\}$/.test(argumentsList[1].text)) return false;
-  for (const match of argumentsList[1].text.matchAll(/\b(?:skip|todo)\s*:\s*([^,}]{1,200})/g)) {
-    if (simpleConstantValue(match[1]) !== false) return false;
-  }
-  return true;
+  const options = argumentsList[1].text;
+  if (/\.\.\.|\[[^\]]+\]\s*:|__pi_(?:bound_string_\d+__|string_literal__)\s*:/.test(options)) return false;
+  const withoutDisabledFlags = options.replace(/\b(?:skip|todo)\s*:\s*false\b/g, "");
+  return !/\b(?:skip|todo)\b/.test(withoutDisabledFlags);
 }
 
 function callbackBodyRange(text, argument) {
-  const value = text.slice(argument.start, argument.end);
-  const arrow = value.indexOf("=>");
-  const functionBody = arrow === -1 ? value.indexOf("{") : -1;
-  let bodyStart = argument.start + (arrow === -1 ? functionBody : arrow + 2);
-  if (bodyStart < argument.start) return undefined;
+  let expressionStart = argument.start, expressionEnd = argument.end;
+  while (/\s/.test(text[expressionStart] ?? "")) expressionStart += 1;
+  while (/\s/.test(text[expressionEnd - 1] ?? "")) expressionEnd -= 1;
+  while (text[expressionStart] === "(" && balancedEnd(text, expressionStart) === expressionEnd) {
+    expressionStart += 1; expressionEnd -= 1;
+    while (/\s/.test(text[expressionStart] ?? "")) expressionStart += 1;
+    while (/\s/.test(text[expressionEnd - 1] ?? "")) expressionEnd -= 1;
+  }
+  const value = text.slice(expressionStart, expressionEnd);
+  const arrow = value.match(/^(?:async\s+)?(?:\([^)]*\)|[a-z_$][a-z0-9_$]*)\s*=>\s*/i);
+  const callable = arrow ?? value.match(/^(?:async\s+)?function(?:\s+[a-z_$][a-z0-9_$]*)?\s*\([^)]*\)\s*/i);
+  if (!callable) return undefined;
+  let bodyStart = expressionStart + callable[0].length;
   while (/\s/.test(text[bodyStart] ?? "")) bodyStart += 1;
-  if (text[bodyStart] !== "{") return arrow === -1 ? undefined : { start: bodyStart, end: argument.end, braced: false };
+  if (text[bodyStart] !== "{") return arrow ? { start: bodyStart, end: expressionEnd, braced: false } : undefined;
   const end = balancedEnd(text, bodyStart, "{", "}");
-  return end === -1 || end > argument.end + 1 ? undefined : { start: bodyStart + 1, end: end - 1, braced: true };
+  return end !== expressionEnd ? undefined : { start: bodyStart + 1, end: end - 1, braced: true };
 }
 
-export function executableRejectionAssertions(testText, callableNames, modeHintsOnly = false) {
+export function executableRejectionAssertions(testText, callableNames, modeHintsOnly = false, includeSuccess = false,
+  literalIterationEnvironmentStable = true) {
   const assertions = [];
   const carrierBindings = assertionCarrierBindings(testText);
   const assertionCarriers = new Set((assertionEvidenceFileSupported(testText)
     && carrierBindings.length === 1 && nodeAssertModuleReferenceCount(testText) === 1 ? carrierBindings : [])
     .filter((binding) => assertionCarrierIsStable(testText, binding))
     .map((binding) => binding.name));
+  const runnerBindings = testRunnerBindings(testText);
+  const liveRunnerBindings = new Map(runnerBindings
+    .filter((binding) => importedCallableBindingIsStable(testText, binding, runnerBindings))
+    .map((binding) => [binding.name, binding.kind]));
+  const literalIterationStable = literalIterationEnvironmentStable
+    && literalArrayIterationEnvironmentIsStable(testText);
+  const registrationNames = (kind, fallbacks) => uniqueStrings([
+    ...fallbacks, ...runnerBindings.filter((binding) => binding.kind === kind).map((binding) => binding.name)
+  ]);
+  const registrationPattern = (names, suffix) => new RegExp(
+    `\\b(${names.map(escapeRegex).join("|")})${suffix}\\s*\\(`, "gi"
+  );
+  const suiteNames = registrationNames("suite", ["context", "describe", "suite"]);
+  const testNames = registrationNames("test", ["it", "specify", "test"]);
   const declarationRanges = assertionHelperDeclarations(testText).map(({ start, end }) => ({ start, end }));
   const skippedRanges = [];
   const suiteRanges = [];
   const registeredRanges = [];
-  for (const match of testText.matchAll(/\b(?:context|describe|it|specify|suite|test)\.(?:skip|todo)\s*\(/g)) {
+  for (const match of testText.matchAll(registrationPattern([...suiteNames, ...testNames], "\\.(?:skip|todo)"))) {
     const open = testText.indexOf("(", match.index);
     const end = balancedEnd(testText, open);
     if (end !== -1) skippedRanges.push({ start: match.index, end });
   }
-  for (const match of testText.matchAll(/\b(?:context|describe|suite)(?:\.only)?\s*\(/g)) {
+  for (const match of testText.matchAll(registrationPattern(suiteNames, "(?:\\.only)?"))) {
     const open = testText.indexOf("(", match.index);
     const end = balancedEnd(testText, open);
     if (end === -1) continue;
     const argumentsList = topLevelArgumentRanges(testText, open, end);
     const callback = callbackBodyRange(testText, argumentsList.at(-1));
-    if (!registrationArgumentsEnabled(argumentsList) || !callback) skippedRanges.push({ start: match.index, end });
-    else suiteRanges.push({ ...callback, callStart: match.index });
+    if (liveRunnerBindings.get(match[1].toLowerCase()) !== "suite"
+      || !registrationArgumentsEnabled(argumentsList) || !callback) skippedRanges.push({ start: match.index, end });
+    else suiteRanges.push({ ...callback, callStart: match.index, tupleCallbackClosed: tupleRegistrationIsClosed(argumentsList) });
   }
-  for (const match of testText.matchAll(/\b(?:it|specify|test)(?:\.(?:concurrent|only))?\s*\(/g)) {
+  for (const match of testText.matchAll(registrationPattern(testNames, "(?:\\.(?:concurrent|only))?"))) {
     const open = testText.indexOf("(", match.index);
     const end = balancedEnd(testText, open);
     if (end === -1) continue;
     const argumentsList = topLevelArgumentRanges(testText, open, end);
     const callback = callbackBodyRange(testText, argumentsList.at(-1));
-    if (!registrationArgumentsEnabled(argumentsList) || !callback) skippedRanges.push({ start: match.index, end });
-    else registeredRanges.push({ ...callback, callStart: match.index });
+    if (liveRunnerBindings.get(match[1].toLowerCase()) !== "test"
+      || !registrationArgumentsEnabled(argumentsList) || !callback) skippedRanges.push({ start: match.index, end });
+    else registeredRanges.push({ ...callback, callStart: match.index, tupleCallbackClosed: tupleRegistrationIsClosed(argumentsList) });
   }
   const bracedDepthAt = (offset) => {
     let depth = 0;
@@ -335,16 +604,8 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
   const topLevelCall = (start) => {
     if (bracedDepthAt(start) !== 0) return false;
     const prefix = testText.slice(Math.max(testText.lastIndexOf(";", start - 1) + 1, 0), start);
-    return !/=>|\bfunction\b|\?|&&/.test(prefix);
+    return !/=>|\bfunction\b|\?|&&|\|\|/.test(prefix);
   };
-  const liveSuites = [];
-  for (const suite of suiteRanges) {
-    if (topLevelCall(suite.callStart) || liveSuites.some((range) => rangeDirectlyContains(range, suite.callStart))) liveSuites.push(suite);
-  }
-  suiteRanges.splice(0, suiteRanges.length, ...liveSuites);
-  const liveRegistrations = registeredRanges.filter((range) => topLevelCall(range.callStart)
-    || suiteRanges.some((suite) => rangeDirectlyContains(suite, range.callStart)));
-  registeredRanges.splice(0, registeredRanges.length, ...liveRegistrations);
   const statementRange = (start) => {
     let bodyStart = start;
     while (/\s/.test(testText[bodyStart] ?? "")) bodyStart += 1;
@@ -352,6 +613,53 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     const semicolon = testText.indexOf(";", bodyStart);
     return { start: bodyStart, end: semicolon === -1 ? testText.length : semicolon + 1 };
   };
+  const statementAbruptlyExits = (raw) => {
+    let body = String(raw ?? "").trim();
+    if (body.startsWith("{") && balancedEnd(body, 0, "{", "}") === body.length) body = body.slice(1, -1).trim();
+    return /^(?:(?:break|continue)\s*;?|return(?:[ \t]+[^;{}\r\n]*)?\s*;?|throw\s+[^;{}]+\s*;?|process\.exit\s*\([^;{}]*\)\s*;?)$/.test(body);
+  };
+  const directStatementAtDepth = (containerStart, offset, baseDepth) => {
+    let boundary = containerStart, braces = baseDepth, brackets = 0, parentheses = 0;
+    for (let index = containerStart; index < offset; index += 1) {
+      const character = testText[index];
+      if (character === "{") braces += 1;
+      else if (character === "}") { braces = Math.max(0, braces - 1); if (braces === baseDepth) boundary = index + 1; }
+      else if (braces === baseDepth && character === "[") brackets += 1;
+      else if (braces === baseDepth && character === "]") brackets -= 1;
+      else if (braces === baseDepth && character === "(") parentheses += 1;
+      else if (braces === baseDepth && character === ")") parentheses -= 1;
+      else if (braces === baseDepth && !brackets && !parentheses && character === ";") boundary = index + 1;
+    }
+    return !testText.slice(boundary, offset).trim();
+  };
+  const abruptBefore = (containerStart, start, baseDepth) => {
+    const prefix = testText.slice(containerStart, start);
+    for (const match of prefix.matchAll(/\b(?:break|continue|return|throw)\b|\bprocess\s*\.\s*exit\s*\(/g)) {
+      const absolute = containerStart + match.index;
+      if (bracedDepthAt(absolute) === baseDepth && directStatementAtDepth(containerStart, absolute, baseDepth)) return true;
+    }
+    for (const match of prefix.matchAll(/\bif\s*\(/g)) {
+      const absolute = containerStart + match.index;
+      if (bracedDepthAt(absolute) !== baseDepth || !directStatementAtDepth(containerStart, absolute, baseDepth)) continue;
+      const open = testText.indexOf("(", absolute), conditionEnd = balancedEnd(testText, open);
+      if (conditionEnd === -1 || conditionEnd > start
+        || simpleConstantValue(testText.slice(open + 1, conditionEnd - 1)) === false) continue;
+      const consequent = statementRange(conditionEnd);
+      if (consequent.end !== -1 && consequent.end <= start
+        && statementAbruptlyExits(testText.slice(consequent.start, consequent.end))) return true;
+    }
+    return false;
+  };
+  const topLevelAbruptBefore = (start) => abruptBefore(0, start, 0);
+  const liveSuites = [];
+  for (const suite of suiteRanges) {
+    if (!topLevelAbruptBefore(suite.callStart)
+      && (topLevelCall(suite.callStart) || liveSuites.some((range) => rangeDirectlyContains(range, suite.callStart)))) liveSuites.push(suite);
+  }
+  suiteRanges.splice(0, suiteRanges.length, ...liveSuites);
+  const liveRegistrations = registeredRanges.filter((range) => !topLevelAbruptBefore(range.callStart)
+    && (topLevelCall(range.callStart) || suiteRanges.some((suite) => rangeDirectlyContains(suite, range.callStart))));
+  registeredRanges.splice(0, registeredRanges.length, ...liveRegistrations);
   const conditionalRanges = [];
   for (const match of testText.matchAll(/\bif\s*\(/g)) {
     const open = testText.indexOf("(", match.index);
@@ -369,16 +677,35 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
   }
   const triviallyDisabled = (start) => {
     const prefix = testText.slice(Math.max(0, start - 600), start);
-    if (prefix.match(/(?:^|[;{])\s*(?:\(([^()]{1,160})\)|([^;{}()]{1,160}))\s*&&[\s\S]{0,400}$/)) return true;
+    if (prefix.match(/(?:^|[;{])\s*(?:\(([^()]{1,160})\)|([^;{}()]{1,160}))\s*(?:&&|\|\|)[\s\S]{0,400}$/)) return true;
     return Boolean(prefix.match(/(?:^|[;{])\s*(?:\(([^()]{1,160})\)|([^;{}()]{1,160}))\s*\?[\s\S]{0,400}$/));
   };
   const directlyInside = rangeDirectlyContains;
+  const transparentTryRanges = [];
   const directBaseContext = (start) => {
-    if (registeredRanges.some((range) => directlyInside(range, start))) return true;
+    if ([...registeredRanges, ...transparentTryRanges].some((range) => directlyInside(range, start))) return true;
     if (bracedDepthAt(start) !== 0) return false;
     const prefix = testText.slice(Math.max(testText.lastIndexOf(";", start - 1) + 1, 0), start);
     return !/=>|\bfunction\b/.test(prefix);
   };
+  // A catch-free try with a restoration-only finally cannot turn a failed
+  // assertion into success. Keep the body in the same live registration;
+  // catches, abrupt finalizers and uncalled/nested conditional blocks abstain.
+  for (const match of testText.matchAll(/\btry\s*\{/g)) {
+    if (!directBaseContext(match.index) || triviallyDisabled(match.index)
+      || [...declarationRanges, ...skippedRanges, ...conditionalRanges].some(range => match.index >= range.start && match.index < range.end)) continue;
+    const parent = [...registeredRanges, ...transparentTryRanges].filter(range => directlyInside(range, match.index)).at(-1);
+    if (abruptBefore(parent?.start ?? 0, match.index, bracedDepthAt(parent?.start ?? 0))) continue;
+    const open = testText.indexOf("{", match.index), end = balancedEnd(testText, open, "{", "}");
+    if (end === -1) continue;
+    const finalizer = testText.slice(end).match(/^\s*finally\s*\{/);
+    if (!finalizer) continue;
+    const finalOpen = end + finalizer[0].lastIndexOf("{"), finalEnd = balancedEnd(testText, finalOpen, "{", "}");
+    if (finalEnd === -1) continue;
+    const cleanup = testText.slice(finalOpen + 1, finalEnd - 1);
+    if (!/^(?:\s*[a-z_$][a-z0-9_$]*(?:\s*\.\s*[a-z_$][a-z0-9_$]*)*\s*=\s*[a-z_$][a-z0-9_$]*\s*;)*\s*$/i.test(cleanup)) continue;
+    transparentTryRanges.push({ start: open + 1, end: end - 1, braced: true });
+  }
   const structurallyConnected = (start) => directBaseContext(start)
     && ![...declarationRanges, ...skippedRanges, ...conditionalRanges].some((range) => start >= range.start && start < range.end)
     && !triviallyDisabled(start);
@@ -408,6 +735,24 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
   };
   const iterationRanges = [];
   const unsupportedControlRanges = [];
+  const tupleAncestryIsClosed = (start) => {
+    const callbacks = [...suiteRanges, ...registeredRanges];
+    const ancestry = callbacks.filter((range) => start >= range.start && start < range.end).sort((a, b) => a.start - b.start);
+    if (ancestry.some((range) => !range.tupleCallbackClosed)) return false;
+    let parentStart = 0;
+    for (const child of [...ancestry, { callStart: start }]) {
+      const masked = callbacks.filter((range) => range.start >= parentStart && range.end <= child.callStart);
+      let prefix = testText.slice(parentStart, child.callStart);
+      for (const range of masked.sort((a, b) => b.start - a.start)) {
+        prefix = `${prefix.slice(0, range.start - parentStart)}${" ".repeat(range.end - range.start)}${prefix.slice(range.end - parentStart)}`;
+      }
+      if (/\b(?:return|throw|break|continue|if|switch|try|catch|finally|while|do|yield|await|with)\b/.test(prefix)
+        || unsupportedControlRanges.some((range) => range.start >= parentStart && range.end <= child.callStart
+          && !masked.some((callback) => range.start >= callback.start && range.end <= callback.end))) return false;
+      parentStart = child.start;
+    }
+    return true;
+  };
   for (const match of testText.matchAll(/\bfor\s*\(/g)) {
     if (!structurallyConnected(match.index)) continue;
     const open = testText.indexOf("(", match.index);
@@ -418,8 +763,23 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     const header = testText.slice(open + 1, headerEnd - 1);
     const iterationBody = testText[body.start] === "{" ? { start: body.start + 1, end: body.end - 1, braced: true } : { ...body, braced: false };
     const forOf = header.match(/^\s*(?:const|let)\s+([a-z_$][a-z0-9_$]*)\s+of\s+([\s\S]+?)\s*$/i);
-    const iterable = forOf && iterationLiteral(forOf[2], match.index);
+    const iterable = forOf && literalIterationStable && iterationLiteral(forOf[2], match.index);
+    const tuple = header.match(/^\s*const\s+\[\s*([a-z_$][a-z0-9_$]*)\s*,\s*([a-z_$][a-z0-9_$]*)\s*,?\s*\]\s+of\s+([\s\S]+?)\s*$/i);
+    const tupleIterable = tuple && literalIterationStable && iterationLiteral(tuple[3], match.index);
+    const tupleRows = tupleIterable && constantTupleRows(tupleIterable.literal, testText);
+    const tupleVariables = tuple?.slice(1, 3);
+    const protectedNames = new Set([...ERROR_CONSTRUCTORS, "date", "number", "nan", "infinity", "undefined",
+      ...assertionCarriers, ...liveRunnerBindings.keys(), ...[...callableNames].flatMap((name) => name.split("."))]);
+    const tupleBindingClosed = tupleIterable && (!tupleIterable.binding
+      || [...testText.matchAll(new RegExp(`\\b${escapeRegex(tupleIterable.binding)}\\b`, "g"))].length === 2);
+    const tupleContainerStart = registrationAt(match.index)?.start ?? 0;
+    const tupleReachable = !abruptBefore(tupleContainerStart, match.index, bracedDepthAt(tupleContainerStart));
     if (iterable) iterationRanges.push({ ...iterationBody, ...iterable, kind: "for-of", variable: forOf[1] });
+    else if (tupleRows && tupleBindingClosed && tupleReachable && tupleAncestryIsClosed(match.index)
+      && tupleTargetImportsAreStable(testText, callableNames) && new Set(tupleVariables).size === 2
+      && tupleVariables.every((name) => !protectedNames.has(name))) {
+      iterationRanges.push({ ...iterationBody, ...tupleIterable, kind: "for-of", tupleRows, tupleVariables });
+    }
     else if (modeHintsOnly && forOf) iterationRanges.push({ ...iterationBody, kind: "for-of", variable: forOf[1] });
     else unsupportedControlRanges.push(body);
   }
@@ -436,7 +796,7 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
       receiverStart = receiver ? receiverStart - receiver[1].length : -1;
     }
     const receiverText = receiverStart < 0 ? "" : testText.slice(receiverStart, match.index).trim();
-    const iterable = receiverStart < 0 ? undefined : iterationLiteral(receiverText, receiverStart);
+    const iterable = receiverStart < 0 || !literalIterationStable ? undefined : iterationLiteral(receiverText, receiverStart);
     const argumentsList = topLevelArgumentRanges(testText, open, end);
     const callback = callbackBodyRange(testText, argumentsList.at(-1));
     const callbackText = argumentsList.at(-1)?.text ?? "";
@@ -450,11 +810,11 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     if (headerEnd !== -1) unsupportedControlRanges.push(statementRange(headerEnd));
   }
   const abruptlyUnreachable = (start) => {
-    const containers = [...registeredRanges, ...iterationRanges]
+    const containers = [...registeredRanges, ...transparentTryRanges, ...iterationRanges]
       .filter((range) => start >= range.start && start < range.end)
       .sort((left, right) => right.start - left.start);
-    const prefix = testText.slice(containers[0]?.start ?? 0, start);
-    return /(?:^|[;{}])\s*(?:break|continue|return(?:\s+[^;{}]*)?|throw\s+[^;{}]+|process\.exit\s*\([^;{}]*\));[\s\S]*$/.test(prefix);
+    return (containers.length > 0 ? containers : [{ start: 0 }])
+      .some(container => abruptBefore(container.start, start, bracedDepthAt(container.start)));
   };
   const iterationVariableIsLive = (range, start) => {
     const escaped = escapeRegex(range.variable);
@@ -488,6 +848,34 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
       const returnedConciseCallback = registeredRanges.some((range) => !range.braced && start === range.start);
       if (!/^(?:await|return(?:\s+await)?)$/.test(promisePrefix) && !returnedConciseCallback) return;
     }
+    const tupleIteration = containingIterations.find((range) => range.tupleRows);
+    if (tupleIteration) {
+      const tuplePrefix = testText.slice(tupleIteration.start, start).trim();
+      if (containingIterations.length !== 1 || !["throws", "rejects"].includes(mode)
+        || tuplePrefix !== (mode === "rejects" ? "await" : "")
+        || testText.slice(end, tupleIteration.end).replace(/;/g, "").trim()) return;
+      const callback = String(operation ?? "").trim();
+      const expectedErrors = tupleExpectedErrorClasses(assertion);
+      if (!expectedErrors) return;
+      if (mode === "throws" && /^async\b/.test(callback)) return;
+      const invocation = callback.match(/^(?:async\s+)?\(\s*\)\s*=>\s*([a-z_$][a-z0-9_$.]*)\s*\(/i);
+      const open = invocation ? callback.indexOf("(", invocation[0].length - 1) : -1;
+      const callEnd = open < 0 ? -1 : balancedEnd(callback, open);
+      const argumentsList = callEnd === callback.length ? topLevelArgumentRanges(callback, open, callEnd).map((item) => item.text) : [];
+      if (argumentsList.length !== 2 || new Set(argumentsList).size !== 2
+        || argumentsList.some((argument) => !tupleIteration.tupleVariables.includes(argument))) return;
+      const targets = operationTargets(operation, callableNames);
+      if (targets.length !== 1) return;
+      // Expand each closed row independently. Values never migrate between
+      // argument positions or assertions with different expected error classes.
+      for (const row of tupleIteration.tupleRows) {
+        const values = argumentsList.map((argument) => row[tupleIteration.tupleVariables.indexOf(argument)]);
+        const expanded = `${callback.slice(0, open + 1)}${values.join(", ")})`;
+        assertions.push({ targets, errorClasses: expectedErrors, partitions: evidencePartitionSignals(expanded), mode, operation: expanded,
+          iterationLiterals: [], iterationVariables: [], iterationBindings: [] });
+      }
+      return;
+    }
     const referencedIterations = containingIterations.filter((range) => (
       new RegExp(`\\b${escapeRegex(range.variable)}\\b`, "i").test(assertion)
     ));
@@ -498,7 +886,13 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     for (const range of referencedIterations) {
       if (range.literal) for (const signal of literalArrayPartitionSignals(range.literal)) partitions.add(signal);
     }
-    assertions.push({ targets, errorClasses, partitions, mode });
+    assertions.push({
+      targets, errorClasses, partitions, mode, operation,
+      iterationLiterals: referencedIterations.map((range) => range.literal).filter(Boolean).slice(0, 8),
+      iterationVariables: referencedIterations.map((range) => range.variable).filter(Boolean).slice(0, 8),
+      iterationBindings: referencedIterations.map((range) => ({ variable: range.variable, literal: range.literal }))
+        .filter((item) => item.variable && item.literal).slice(0, 8)
+    });
   };
   for (const match of testText.matchAll(/\b([a-z_$][a-z0-9_$]*)\.(?:throws|rejects)\s*\(/gi)) {
     if (!assertionCarriers.has(match[1].toLowerCase())) continue;
@@ -508,6 +902,14 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     record(match.index, end, evidenceErrorClasses(end === -1 ? "" : testText.slice(match.index, end)), argumentsList[0]?.text,
       /\.rejects\s*\(/i.test(match[0]) ? "rejects" : "throws");
   }
+  if (includeSuccess) for (const match of testText.matchAll(/\b([a-z_$][a-z0-9_$]*)\.(doesnotthrow|deepequal|deepstrictequal|equal|strictequal|notequal|notstrictequal|ok)\s*\(/gi)) {
+    if (!assertionCarriers.has(match[1].toLowerCase())) continue;
+    const open = testText.indexOf("(", match.index);
+    const end = balancedEnd(testText, open);
+    const argumentsList = end === -1 ? [] : topLevelArgumentRanges(testText, open, end);
+    if (match[2].toLowerCase() !== "doesnotthrow" && /^(?:async\s*)?(?:function\b|(?:\([^)]*\)|[a-z_$][a-z0-9_$]*)\s*=>)/i.test(argumentsList[0]?.text ?? "")) continue;
+    record(match.index, end, [], argumentsList[0]?.text, "does-not-throw");
+  }
   for (const helper of rejectionAssertionHelpers(testText, assertionCarriers)) {
     for (const match of testText.matchAll(new RegExp(`\\b${escapeRegex(helper.name)}\\s*\\(`, "g"))) {
       if (match.index >= helper.start && match.index < helper.end) continue;
@@ -530,5 +932,5 @@ export function executableRejectionAssertions(testText, callableNames, modeHints
     record(match.index, end, evidenceErrorClasses(end === -1 ? "" : testText.slice(match.index, end)), argumentsList[0]?.text,
       /\.rejects/i.test(chain[0]) ? "rejects" : "throws");
   }
-  return assertions.slice(0, 64);
+  return annotateInvalidArgumentCoverage(assertions).slice(0, 64);
 }