tamperward 2.17.0 → 2.17.1

package/README.md

@@ -513,6 +513,13 @@ Seventeen rules are specified and sixteen ship (see the table in
 (`ts-any-cast`, `ts-any-launder`, `lint-suppression`), pipeline protection
 (`ci-tampering`, `hook-tampering`, `no-verify`), and the effect/outcome layers
 (`transient-protected-mutation`, `pristine-verification`, plus the `run` envelope).
+`test-skip` keeps the established regex coverage for diff-only inputs and non-JS
+ecosystems, while full parse-clean JS/TS BEFORE/AFTER changes also use a conservative
+TypeScript AST path for multiline member chains, statically-computable properties,
+known test-runner aliases and node:test-style option objects. Resolution is lexical
+(symbol-based), dynamic computed properties are not guessed, statically false shorthand
+options are clean, and trivia-free BEFORE/AFTER semantic identity prevents formatting-only
+rewrites from re-blocking an already-existing skip/focus.
 `assertion-weakening` ships only the AST-proven one-way subset — statically
 proven exact/structural values weakened to truthy/defined, positive exception
 specificity removed, or a pure assertion removed from the same suite-qualified

package/dist/cli/index.js

@@ -1385,6 +1385,7 @@ var lintSuppression = {
 };
 
 // src/detectors/test-skip.ts
+import ts2 from "typescript";
 var RULE3 = "test-skip";
 var acc = (names) => `(?:\\s*\\.\\s*(?:${names})(?![\\w$])|\\s*\\[\\s*['"\`](?:${names})['"\`]\\s*\\])`;
 var JS_RUNNER = "\\b(?:it|test|describe|suite)";
@@ -1393,10 +1394,10 @@ var PATTERNS2 = {
   js: [
     // The skip/only/todo family on a runner, by dot-or-bracket access, with one optional
     // vitest concurrency modifier hop: test.skip, test . skip, test['skip'], it.concurrent.skip.
-    { re: new RegExp(JS_RUNNER + acc(JS_MOD) + "?" + acc("skip|only|todo")), why: "a .skip/.only/.todo marker" },
-    { re: new RegExp(JS_RUNNER + acc("skipIf|runIf") + "\\s*\\("), why: "a .skipIf()/.runIf() condition (the test runs only when the condition allows)" },
-    { re: new RegExp(JS_RUNNER + acc("fails|failing") + "\\s*\\("), why: "a .fails/.failing marker (the test now passes by failing)" },
-    { re: /\b(?:it|test|describe)\.each\s*\(\s*\[\s*\]\s*\)/, why: "an empty .each table (no case ever runs)" },
+    { re: new RegExp(JS_RUNNER + acc(JS_MOD) + "?" + acc("skip|only|todo")), why: "a .skip/.only/.todo marker", astOwned: true },
+    { re: new RegExp(JS_RUNNER + acc("skipIf|runIf") + "\\s*\\("), why: "a .skipIf()/.runIf() condition (the test runs only when the condition allows)", astOwned: true },
+    { re: new RegExp(JS_RUNNER + acc("fails|failing") + "\\s*\\("), why: "a .fails/.failing marker (the test now passes by failing)", astOwned: true },
+    { re: /\b(?:it|test|describe)\.each\s*\(\s*\[\s*\]\s*\)/, why: "an empty .each table (no case ever runs)", astOwned: true },
     { re: /\b(?:xit|xtest|xdescribe)\s*\(/, why: "an x-prefixed disabled test" },
     { re: /\b(?:fit|ftest|fdescribe)\s*\(/, why: "an f-prefixed focused test (narrows the suite)" },
     { re: /\bpending\(\s*\)/, why: "a pending() marker" },
@@ -1406,7 +1407,7 @@ var PATTERNS2 = {
     // In options position (right after the title) ANY value but false/0 skips — a
     // non-literal `{ skip: process.env.CI }` included. Elsewhere on a line only the
     // literal forms count: `list({ skip: 1, take: 5 })` is pagination.
-    { re: /\b(?:it|test|describe|suite)\s*\(\s*(['"`])(?:(?!\1).)*\1\s*,\s*\{[^}]*?\bskip:(?!\s*(?:false|0)\b)/, why: "a { skip: ... } option disabling the test (node:test options form)" },
+    { re: /\b(?:it|test|describe|suite)\s*\(\s*(['"`])(?:(?!\1).)*\1\s*,\s*\{[^}]*?\bskip:(?!\s*(?:false|0)\b)/, why: "a { skip: ... } option disabling the test (node:test options form)", astOwned: true },
     { re: /\bskip:\s*(?:true|['"`])/, why: "a { skip: ... } option disabling the test (node:test options form)" },
     { re: /\btodo:\s*(?:true|['"`])/, why: "a { todo: ... } option (the test no longer fails the run)" },
     { re: new RegExp("\\b(?:t|ctx|context|this)" + acc("skip") + "\\s*\\("), why: "a runtime t.skip()/this.skip() call" }
@@ -1477,6 +1478,343 @@ function matchesOutsideString(p, content, lang) {
   }
   return false;
 }
+var JS_RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe", "suite"]);
+var JS_CHAIN_MODIFIERS = /* @__PURE__ */ new Set(["concurrent", "sequential", "shuffle"]);
+var JS_TEST_MODULES = /* @__PURE__ */ new Set([
+  "vitest",
+  "@jest/globals",
+  "node:test",
+  "node:test/promises",
+  "mocha",
+  "bun:test",
+  "@playwright/test"
+]);
+function scriptKind(path) {
+  if (/\.tsx$/i.test(path)) return ts2.ScriptKind.TSX;
+  if (/\.jsx$/i.test(path)) return ts2.ScriptKind.JSX;
+  if (/\.(?:js|mjs|cjs)$/i.test(path)) return ts2.ScriptKind.JS;
+  return ts2.ScriptKind.TS;
+}
+function addedLineNumbers(c) {
+  const out2 = /* @__PURE__ */ new Set();
+  for (const h of c.hunks) {
+    for (const line of h.lines) {
+      if (line.type === "add" && line.newLine != null) out2.add(line.newLine);
+    }
+  }
+  return out2;
+}
+function moduleName(expr) {
+  return ts2.isStringLiteralLike(expr) ? expr.text : null;
+}
+function requiredModule(expr) {
+  if (!ts2.isCallExpression(expr) || !ts2.isIdentifier(expr.expression) || expr.expression.text !== "require" || expr.arguments.length !== 1) return null;
+  return moduleName(expr.arguments[0]);
+}
+function astContext(path, source) {
+  const rootName = path.startsWith("/") ? path : "/tamperward/" + path;
+  const sf = ts2.createSourceFile(
+    rootName,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    scriptKind(path)
+  );
+  const diagnostics = sf.parseDiagnostics ?? [];
+  if (diagnostics.length > 0) return null;
+  const options = {
+    allowJs: true,
+    checkJs: false,
+    noLib: true,
+    noResolve: true,
+    target: ts2.ScriptTarget.Latest,
+    module: ts2.ModuleKind.ESNext
+  };
+  const host = ts2.createCompilerHost(options, true);
+  host.getSourceFile = (fileName) => fileName === rootName ? sf : void 0;
+  host.fileExists = (fileName) => fileName === rootName;
+  host.readFile = (fileName) => fileName === rootName ? source : void 0;
+  host.writeFile = () => {
+  };
+  host.getDefaultLibFileName = () => "";
+  host.getCurrentDirectory = () => "/tamperward";
+  host.getCanonicalFileName = (fileName) => fileName;
+  host.useCaseSensitiveFileNames = () => true;
+  host.getNewLine = () => "\n";
+  const program = ts2.createProgram([rootName], options, host);
+  return { sf, checker: program.getTypeChecker() };
+}
+function symbolAt(ctx, node) {
+  return ctx.checker.getSymbolAtLocation(node) ?? null;
+}
+function importAliases(ctx) {
+  const out2 = /* @__PURE__ */ new Map();
+  const simpleAliases = [];
+  const add = (id, causes = [id]) => {
+    const sym = symbolAt(ctx, id);
+    if (sym) out2.set(sym, { causes });
+  };
+  for (const stmt of ctx.sf.statements) {
+    if (ts2.isImportDeclaration(stmt) && ts2.isStringLiteralLike(stmt.moduleSpecifier)) {
+      if (!JS_TEST_MODULES.has(stmt.moduleSpecifier.text)) continue;
+      const clause = stmt.importClause;
+      if (!clause) continue;
+      if (clause.name && stmt.moduleSpecifier.text.startsWith("node:test")) add(clause.name);
+      const bindings = clause.namedBindings;
+      if (bindings && ts2.isNamedImports(bindings)) {
+        for (const el of bindings.elements) {
+          const imported = el.propertyName?.text ?? el.name.text;
+          if (JS_RUNNERS.has(imported)) add(el.name);
+        }
+      }
+      continue;
+    }
+    if (!ts2.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (ts2.isObjectBindingPattern(decl.name) && decl.initializer) {
+        const mod = requiredModule(decl.initializer);
+        if (!mod || !JS_TEST_MODULES.has(mod)) continue;
+        for (const el of decl.name.elements) {
+          if (!ts2.isIdentifier(el.name)) continue;
+          const imported = el.propertyName && ts2.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+          if (JS_RUNNERS.has(imported)) add(el.name);
+        }
+      } else if (ts2.isIdentifier(decl.name) && decl.initializer && ts2.isIdentifier(decl.initializer)) {
+        simpleAliases.push({ local: decl.name, source: decl.initializer });
+      }
+    }
+  }
+  for (let pass = 0; pass < simpleAliases.length + 1; pass++) {
+    let changed = false;
+    for (const alias of simpleAliases) {
+      const localSym = symbolAt(ctx, alias.local);
+      if (!localSym || out2.has(localSym)) continue;
+      const sourceSym = symbolAt(ctx, alias.source);
+      const sourceBinding = sourceSym ? out2.get(sourceSym) : void 0;
+      const implicitGlobal = sourceSym == null && JS_RUNNERS.has(alias.source.text);
+      if (!sourceBinding && !implicitGlobal) continue;
+      out2.set(localSym, {
+        causes: [alias.local, ...sourceBinding?.causes ?? []]
+      });
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return out2;
+}
+function topLevelStaticStrings(ctx) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const stmt of ctx.sf.statements) {
+    if (!ts2.isVariableStatement(stmt)) continue;
+    const isConst = (stmt.declarationList.flags & ts2.NodeFlags.Const) !== 0;
+    if (!isConst) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts2.isIdentifier(decl.name) || !decl.initializer) continue;
+      const sym = symbolAt(ctx, decl.name);
+      if (sym) pending.set(sym, { decl: decl.name, expr: decl.initializer });
+    }
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const valueOf = (expr) => {
+    if (ts2.isStringLiteralLike(expr)) return { value: expr.text, causes: [] };
+    if (ts2.isParenthesizedExpression(expr)) return valueOf(expr.expression);
+    if (ts2.isBinaryExpression(expr) && expr.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
+      const left = valueOf(expr.left);
+      const right = valueOf(expr.right);
+      if (!left || !right) return null;
+      return { value: left.value + right.value, causes: [...left.causes, ...right.causes] };
+    }
+    if (ts2.isIdentifier(expr)) {
+      const sym = symbolAt(ctx, expr);
+      if (!sym) return null;
+      const cached = resolved.get(sym);
+      if (cached) return cached;
+      const item = pending.get(sym);
+      if (!item || resolving.has(sym)) return null;
+      resolving.add(sym);
+      const nested = valueOf(item.expr);
+      resolving.delete(sym);
+      if (!nested) return null;
+      const result = { value: nested.value, causes: [item.decl, ...nested.causes] };
+      resolved.set(sym, result);
+      return result;
+    }
+    return null;
+  };
+  for (const [sym, item] of pending) {
+    if (resolved.has(sym)) continue;
+    resolving.add(sym);
+    const nested = valueOf(item.expr);
+    resolving.delete(sym);
+    if (nested) resolved.set(sym, { value: nested.value, causes: [item.decl, ...nested.causes] });
+  }
+  return resolved;
+}
+function staticPropertyName(expr, ctx, strings) {
+  if (ts2.isStringLiteralLike(expr)) return { name: expr.text, causes: [] };
+  if (ts2.isParenthesizedExpression(expr)) return staticPropertyName(expr.expression, ctx, strings);
+  if (ts2.isBinaryExpression(expr) && expr.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
+    const left = staticPropertyName(expr.left, ctx, strings);
+    const right = staticPropertyName(expr.right, ctx, strings);
+    if (!left || !right) return null;
+    return { name: left.name + right.name, causes: [...left.causes, ...right.causes] };
+  }
+  if (ts2.isIdentifier(expr)) {
+    const sym = symbolAt(ctx, expr);
+    if (!sym) return null;
+    const value = strings.get(sym);
+    return value ? { name: value.value, causes: value.causes } : null;
+  }
+  return null;
+}
+function runnerChain(expr, ctx, runners, strings) {
+  const props = [];
+  const causes = [];
+  let cur = expr;
+  let terminalNode = expr;
+  while (ts2.isPropertyAccessExpression(cur) || ts2.isElementAccessExpression(cur)) {
+    if (ts2.isPropertyAccessExpression(cur)) {
+      props.unshift(cur.name.text);
+      if (props.length === 1) terminalNode = cur.name;
+      cur = cur.expression;
+      continue;
+    }
+    if (!cur.argumentExpression) return null;
+    const property = staticPropertyName(cur.argumentExpression, ctx, strings);
+    if (!property) return null;
+    props.unshift(property.name);
+    causes.push(...property.causes);
+    if (props.length === 1) terminalNode = cur.argumentExpression;
+    cur = cur.expression;
+  }
+  if (!ts2.isIdentifier(cur)) return null;
+  const sym = symbolAt(ctx, cur);
+  if (sym) {
+    const binding = runners.get(sym);
+    if (!binding) return null;
+    causes.push(...binding.causes);
+  } else if (!JS_RUNNERS.has(cur.text)) {
+    return null;
+  }
+  return { root: cur.text, props, terminalNode, causes };
+}
+function optionDisables(value) {
+  return !(value.kind === ts2.SyntaxKind.FalseKeyword || ts2.isNumericLiteral(value) && Number(value.text) === 0);
+}
+function shorthandOptionDisables(prop, ctx) {
+  const sym = ctx.checker.getShorthandAssignmentValueSymbol(prop) ?? symbolAt(ctx, prop.name);
+  const decl = sym?.valueDeclaration ?? sym?.declarations?.find((d) => ts2.isVariableDeclaration(d));
+  if (!decl || !ts2.isVariableDeclaration(decl) || !decl.initializer) return true;
+  return optionDisables(decl.initializer);
+}
+function structuralNodeKey(node, sf) {
+  const children = node.getChildren(sf);
+  const text = node.text;
+  if (children.length === 0) {
+    return typeof text === "string" ? `${node.kind}:${JSON.stringify(text)}` : String(node.kind);
+  }
+  return `${node.kind}(${children.map((child) => structuralNodeKey(child, sf)).join(",")})`;
+}
+function semanticSkipHits(ctx) {
+  const runners = importAliases(ctx);
+  const strings = topLevelStaticStrings(ctx);
+  const hits = [];
+  const callOrdinals = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts2.isCallExpression(node)) {
+      const callText = node.getText(ctx.sf).trim();
+      const callIdentity = structuralNodeKey(node, ctx.sf);
+      const ordinal = (callOrdinals.get(callIdentity) ?? 0) + 1;
+      callOrdinals.set(callIdentity, ordinal);
+      const callKey = `${callIdentity}\0${ordinal}`;
+      const chain = runnerChain(node.expression, ctx, runners, strings);
+      if (chain) {
+        const { props, terminalNode, causes } = chain;
+        const terminal = props.at(-1);
+        const push = (target, extraCauses, why) => {
+          hits.push({
+            semanticKey: `${callKey}\0${why}`,
+            terminalNode: target,
+            causeNodes: [...causes, ...extraCauses],
+            why,
+            evidence: callText
+          });
+        };
+        if (terminal && (terminal === "skip" || terminal === "only" || terminal === "todo") && props.slice(0, -1).every((p) => JS_CHAIN_MODIFIERS.has(p))) {
+          push(terminalNode, [], "a .skip/.only/.todo marker");
+        } else if (terminal && ["skipIf", "runIf"].includes(terminal) && props.length === 1) {
+          push(terminalNode, [], "a .skipIf()/.runIf() condition (the test runs only when the condition allows)");
+        } else if (terminal && ["fails", "failing"].includes(terminal) && props.length === 1) {
+          push(terminalNode, [], "a .fails/.failing marker (the test now passes by failing)");
+        } else if (terminal === "each" && props.length === 1 && node.arguments.length > 0 && ts2.isArrayLiteralExpression(node.arguments[0]) && node.arguments[0].elements.length === 0) {
+          push(terminalNode, [], "an empty .each table (no case ever runs)");
+        }
+        if (props.length === 0) {
+          for (const arg of node.arguments) {
+            if (!ts2.isObjectLiteralExpression(arg)) continue;
+            for (const prop of arg.properties) {
+              if (ts2.isPropertyAssignment(prop)) {
+                let name = null;
+                let propertyCauses = [];
+                if (ts2.isIdentifier(prop.name) || ts2.isStringLiteralLike(prop.name)) {
+                  name = prop.name.text;
+                } else if (ts2.isComputedPropertyName(prop.name)) {
+                  const resolved = staticPropertyName(prop.name.expression, ctx, strings);
+                  name = resolved?.name ?? null;
+                  propertyCauses = resolved?.causes ?? [];
+                }
+                if (!name || !["skip", "todo", "only"].includes(name)) continue;
+                if (!optionDisables(prop.initializer)) continue;
+                const why = name === "only" ? "an { only: ... } option focusing the test" : name === "todo" ? "a { todo: ... } option (the test no longer fails the run)" : "a { skip: ... } option disabling the test";
+                push(prop.name, propertyCauses, why);
+              } else if (ts2.isShorthandPropertyAssignment(prop) && ["skip", "todo", "only"].includes(prop.name.text)) {
+                if (!shorthandOptionDisables(prop, ctx)) continue;
+                push(prop.name, [], `a { ${prop.name.text} } option that conditionally narrows the test run`);
+              }
+            }
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(ctx.sf);
+  return hits;
+}
+function astSkipHits(c) {
+  if (c.after == null) return { hits: [], authoritative: false };
+  const added = addedLineNumbers(c);
+  if (added.size === 0) return { hits: [], authoritative: false };
+  const afterCtx = astContext(c.path, c.after);
+  if (!afterCtx) return { hits: [], authoritative: false };
+  const beforeCtx = c.before == null ? null : astContext(c.path, c.before);
+  const beforeKeys = beforeCtx == null ? null : new Set(semanticSkipHits(beforeCtx).map((hit) => hit.semanticKey));
+  const lineOf = (node) => afterCtx.sf.getLineAndCharacterOfPosition(node.getStart(afterCtx.sf)).line + 1;
+  const hits = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const hit of semanticSkipHits(afterCtx)) {
+    const directLine = lineOf(hit.terminalNode);
+    let findingLine = added.has(directLine) ? directLine : null;
+    if (findingLine == null) {
+      for (const cause of hit.causeNodes) {
+        const line = lineOf(cause);
+        if (added.has(line)) {
+          findingLine = line;
+          break;
+        }
+      }
+      if (findingLine == null) continue;
+      if (beforeKeys == null) continue;
+    }
+    if (beforeKeys?.has(hit.semanticKey)) continue;
+    const dedupe = `${findingLine}\0${hit.semanticKey}`;
+    if (seen.has(dedupe)) continue;
+    seen.add(dedupe);
+    hits.push({ line: findingLine, why: hit.why, evidence: hit.evidence });
+  }
+  return { hits, authoritative: true };
+}
 var testSkip = {
   id: RULE3,
   surface: ["file"],
@@ -1488,9 +1826,29 @@ var testSkip = {
       if (!isProtected(c.path, policy, "tests")) continue;
       const lang = langOf(c.path);
       const patterns = PATTERNS2[lang ?? "js"];
+      const astHitLines = /* @__PURE__ */ new Set();
+      let astAuthoritative = false;
+      if (lang === "js" && c.after != null) {
+        const analysis = astSkipHits(c);
+        astAuthoritative = analysis.authoritative;
+        for (const hit of analysis.hits) {
+          astHitLines.add(hit.line);
+          out2.push(
+            makeFinding(RULE3, policy, {
+              file: c.path,
+              line: hit.line,
+              message: `Test skipped or narrowed: ${hit.why}.`,
+              evidence: hit.evidence,
+              remediation: "Make the test pass rather than skipping it. If it is genuinely obsolete, a human must sign off."
+            })
+          );
+        }
+      }
       for (const l of addedLines(c)) {
+        if (l.newLine != null && astHitLines.has(l.newLine)) continue;
         const comment = isCommentLine(l.content.trim(), lang);
         for (const p of patterns) {
+          if (astAuthoritative && p.astOwned) continue;
           if (comment && !p.comment) continue;
           if (matchesOutsideString(p, l.content, lang)) {
             out2.push(
@@ -1513,7 +1871,7 @@ var testSkip = {
 
 // src/detectors/coverage-lowering.ts
 import picomatch2 from "picomatch";
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/detectors/repo.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -1641,29 +1999,29 @@ var METRICS = ["branches", "functions", "lines", "statements"];
 var isMetric = (k) => METRICS.includes(k);
 var norm = (p) => p.replace(/^\.\//, "");
 function keyName(name) {
-  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name)) return name.text;
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) return name.text;
   return null;
 }
 function numericOf(e) {
-  if (ts2.isNumericLiteral(e)) return Number(e.text);
-  if (ts2.isStringLiteral(e) && /^-?\d+(?:\.\d+)?$/.test(e.text.trim())) return Number(e.text);
-  if (ts2.isPrefixUnaryExpression(e) && e.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(e.operand)) {
+  if (ts3.isNumericLiteral(e)) return Number(e.text);
+  if (ts3.isStringLiteral(e) && /^-?\d+(?:\.\d+)?$/.test(e.text.trim())) return Number(e.text);
+  if (ts3.isPrefixUnaryExpression(e) && e.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(e.operand)) {
     return -Number(e.operand.text);
   }
   return void 0;
 }
 function metricsOf(expr, resolve9) {
   const obj = resolve9(expr);
-  if (!ts2.isObjectLiteralExpression(obj)) return void 0;
+  if (!ts3.isObjectLiteralExpression(obj)) return void 0;
   const out2 = { values: {}, opaque: false };
   let any = false;
   for (const p of obj.properties) {
-    if (ts2.isSpreadAssignment(p)) {
+    if (ts3.isSpreadAssignment(p)) {
       out2.opaque = true;
       any = true;
       continue;
     }
-    if (!ts2.isPropertyAssignment(p)) continue;
+    if (!ts3.isPropertyAssignment(p)) continue;
     const k = keyName(p.name);
     if (k === null || !isMetric(k)) continue;
     any = true;
@@ -1675,34 +2033,34 @@ function metricsOf(expr, resolve9) {
 }
 function underKey(node, key2) {
   for (let p = node.parent; p; p = p.parent) {
-    if (ts2.isPropertyAssignment(p) && keyName(p.name) === key2) return true;
+    if (ts3.isPropertyAssignment(p) && keyName(p.name) === key2) return true;
   }
   return false;
 }
 function ownerKey(node) {
   const obj = node.parent;
-  if (!obj || !ts2.isObjectLiteralExpression(obj)) return null;
+  if (!obj || !ts3.isObjectLiteralExpression(obj)) return null;
   let q = obj.parent;
-  while (q && (ts2.isParenthesizedExpression(q) || ts2.isAsExpression(q) || q.kind === ts2.SyntaxKind.SatisfiesExpression)) q = q.parent;
-  return q && ts2.isPropertyAssignment(q) ? keyName(q.name) : null;
+  while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts3.isPropertyAssignment(q) ? keyName(q.name) : null;
 }
 function asExpression(src) {
   const t = src.trim();
   return t.startsWith("{") ? `(${t})` : src;
 }
 function sourceOf(src) {
-  return ts2.createSourceFile("cfg.ts", asExpression(src), ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  return ts3.createSourceFile("cfg.ts", asExpression(src), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
 }
 function resolverFor(sf) {
   const consts = /* @__PURE__ */ new Map();
   for (const st of sf.statements) {
-    if (!ts2.isVariableStatement(st)) continue;
+    if (!ts3.isVariableStatement(st)) continue;
     for (const d of st.declarationList.declarations) {
-      if (ts2.isIdentifier(d.name) && d.initializer) consts.set(d.name.text, d.initializer);
+      if (ts3.isIdentifier(d.name) && d.initializer) consts.set(d.name.text, d.initializer);
     }
   }
   return (e) => {
-    if (ts2.isIdentifier(e)) {
+    if (ts3.isIdentifier(e)) {
       const bound = consts.get(e.text);
       return bound ?? e;
     }
@@ -1715,25 +2073,25 @@ function parseThresholds(src) {
     const sf = sourceOf(src);
     const resolve9 = resolverFor(sf);
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const key2 = keyName(node.name);
         if (key2 === "coverageThreshold" || key2 === "thresholds" && underKey(node, "coverage")) {
           res.present = true;
           const init = resolve9(node.initializer);
-          if (!ts2.isObjectLiteralExpression(init)) {
+          if (!ts3.isObjectLiteralExpression(init)) {
             res.opaque = true;
           } else {
             const flat = metricsOf(init, resolve9);
             if (flat) res.global = merge(res.global, flat);
             for (const p of init.properties) {
-              if (ts2.isSpreadAssignment(p)) {
+              if (ts3.isSpreadAssignment(p)) {
                 res.opaque = true;
                 continue;
               }
-              if (!ts2.isPropertyAssignment(p)) continue;
+              if (!ts3.isPropertyAssignment(p)) continue;
               const k = keyName(p.name);
               if (k === null || isMetric(k)) continue;
-              if (key2 === "thresholds" && k === "100" && p.initializer.kind === ts2.SyntaxKind.TrueKeyword) {
+              if (key2 === "thresholds" && k === "100" && p.initializer.kind === ts3.SyntaxKind.TrueKeyword) {
                 res.global = merge(res.global, { values: { branches: 100, functions: 100, lines: 100, statements: 100 }, opaque: false });
                 continue;
               }
@@ -1745,7 +2103,7 @@ function parseThresholds(src) {
           }
         }
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1756,12 +2114,12 @@ function merge(a, b) {
   return { values: { ...a?.values ?? {}, ...b.values }, opaque: (a?.opaque ?? false) || b.opaque };
 }
 function literals(e) {
-  if (ts2.isStringLiteral(e)) return { items: [e.text], opaque: false };
-  if (!ts2.isArrayLiteralExpression(e)) return { items: [], opaque: true };
+  if (ts3.isStringLiteral(e)) return { items: [e.text], opaque: false };
+  if (!ts3.isArrayLiteralExpression(e)) return { items: [], opaque: true };
   const items = [];
   let opaque = false;
   for (const el of e.elements) {
-    if (ts2.isStringLiteral(el) || ts2.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
+    if (ts3.isStringLiteral(el) || ts3.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
     else opaque = true;
   }
   return { items, opaque };
@@ -1772,7 +2130,7 @@ function parseLists(src) {
     const sf = sourceOf(src);
     const resolve9 = resolverFor(sf);
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const k = keyName(node.name);
         const vitestCoverage = ownerKey(node) === "coverage";
         if (k === "collectCoverageFrom" || k === "include" && vitestCoverage) {
@@ -1786,7 +2144,7 @@ function parseLists(src) {
           if (opaque) res.opaqueIgnore = true;
         }
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1797,15 +2155,15 @@ function parseSwitches(src) {
   const res = {};
   try {
     const sf = sourceOf(src);
-    const bool = (e) => e.kind === ts2.SyntaxKind.TrueKeyword ? true : e.kind === ts2.SyntaxKind.FalseKeyword ? false : void 0;
+    const bool = (e) => e.kind === ts3.SyntaxKind.TrueKeyword ? true : e.kind === ts3.SyntaxKind.FalseKeyword ? false : void 0;
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node)) {
+      if (ts3.isPropertyAssignment(node)) {
         const k = keyName(node.name);
         const owner = ownerKey(node);
         if (k === "enabled" && owner === "coverage") res.enabled = bool(node.initializer);
         else if (k === "perFile" && owner === "thresholds" && underKey(node, "coverage")) res.perFile = bool(node.initializer);
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -1818,11 +2176,11 @@ function sectionText(src, key2) {
     let out2 = "";
     const visit = (node) => {
       if (out2) return;
-      if (ts2.isPropertyAssignment(node) && keyName(node.name) === key2 && ts2.isObjectLiteralExpression(node.initializer)) {
+      if (ts3.isPropertyAssignment(node) && keyName(node.name) === key2 && ts3.isObjectLiteralExpression(node.initializer)) {
         out2 = node.initializer.getText(sf);
         return;
       }
-      ts2.forEachChild(node, visit);
+      ts3.forEachChild(node, visit);
     };
     visit(sf);
     return out2;
@@ -5172,11 +5530,11 @@ var hookTampering = {
 };
 
 // src/detectors/test-deletion.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 
 // src/detectors/suite-config.ts
 import picomatch3 from "picomatch";
-import ts3 from "typescript";
+import ts4 from "typescript";
 var JEST_DEFAULT_MATCH = ["**/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)"];
 var JEST_DEFAULT_IGNORE = ["/node_modules/"];
 var VITEST_DEFAULT_INCLUDE = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
@@ -5207,18 +5565,18 @@ var PYTEST_CANONICAL_SAMPLES = [
   "tests/conftest.py"
 ];
 function keyName2(name) {
-  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name)) return name.text;
+  if (ts4.isIdentifier(name) || ts4.isStringLiteral(name)) return name.text;
   return null;
 }
-var isStr = (e) => ts3.isStringLiteral(e) || ts3.isNoSubstitutionTemplateLiteral(e);
+var isStr = (e) => ts4.isStringLiteral(e) || ts4.isNoSubstitutionTemplateLiteral(e);
 function literals2(e) {
   if (isStr(e)) return { items: [e.text], opaque: false };
-  if (!ts3.isArrayLiteralExpression(e)) return { items: [], opaque: true };
+  if (!ts4.isArrayLiteralExpression(e)) return { items: [], opaque: true };
   const items = [];
   let opaque = false;
   for (const el of e.elements) {
     if (isStr(el)) items.push(el.text);
-    else if (ts3.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
+    else if (ts4.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
       items.push(.../exclude$/i.test(el.expression.getText()) ? VITEST_DEFAULT_EXCLUDE : VITEST_DEFAULT_INCLUDE);
     } else opaque = true;
   }
@@ -5226,10 +5584,10 @@ function literals2(e) {
 }
 function ownerKey2(node) {
   const obj = node.parent;
-  if (!obj || !ts3.isObjectLiteralExpression(obj)) return null;
+  if (!obj || !ts4.isObjectLiteralExpression(obj)) return null;
   let q = obj.parent;
-  while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
-  return q && ts3.isPropertyAssignment(q) ? keyName2(q.name) : null;
+  while (q && (ts4.isParenthesizedExpression(q) || ts4.isAsExpression(q) || q.kind === ts4.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts4.isPropertyAssignment(q) ? keyName2(q.name) : null;
 }
 function asExpression2(src) {
   const t = src.trim();
@@ -5370,15 +5728,15 @@ function collect(root, runner) {
     projectList = e;
   };
   const visit = (node) => {
-    if (ts3.isSpreadAssignment(node) && spreadsIntoConfig(node, runner)) {
+    if (ts4.isSpreadAssignment(node) && spreadsIntoConfig(node, runner)) {
       sel.present = true;
       sel.opaque = true;
     }
-    if (ts3.isCallExpression(node) && /^(?:\w+\.)?mergeConfig$/.test(node.expression.getText()) && node.arguments[0] && !ts3.isObjectLiteralExpression(unwrapConfigCall(node.arguments[0]))) {
+    if (ts4.isCallExpression(node) && /^(?:\w+\.)?mergeConfig$/.test(node.expression.getText()) && node.arguments[0] && !ts4.isObjectLiteralExpression(unwrapConfigCall(node.arguments[0]))) {
       sel.present = true;
       sel.opaque = true;
     }
-    if (ts3.isPropertyAssignment(node)) {
+    if (ts4.isPropertyAssignment(node)) {
       const k = keyName2(node.name);
       if (runner === "jest") {
         if (k === "testMatch") sel.include = take(k, node.initializer);
@@ -5408,7 +5766,7 @@ function collect(root, runner) {
         }
       }
     }
-    ts3.forEachChild(node, visit);
+    ts4.forEachChild(node, visit);
   };
   visit(root);
   if (projectList) sel.projects = readProjects(projectList, sel, runner);
@@ -5417,30 +5775,30 @@ function collect(root, runner) {
 }
 function unwrapConfigCall(e) {
   let x = e;
-  while (ts3.isParenthesizedExpression(x) || ts3.isAsExpression(x) || x.kind === ts3.SyntaxKind.SatisfiesExpression) {
+  while (ts4.isParenthesizedExpression(x) || ts4.isAsExpression(x) || x.kind === ts4.SyntaxKind.SatisfiesExpression) {
     x = x.expression;
   }
-  if (ts3.isCallExpression(x) && /^(?:\w+\.)?define(?:Config|Project)$/.test(x.expression.getText()) && x.arguments[0]) return unwrapConfigCall(x.arguments[0]);
+  if (ts4.isCallExpression(x) && /^(?:\w+\.)?define(?:Config|Project)$/.test(x.expression.getText()) && x.arguments[0]) return unwrapConfigCall(x.arguments[0]);
   return x;
 }
 var JEST_SELECTION_KEYS = /^(?:testMatch|testRegex|testPathIgnorePatterns|modulePathIgnorePatterns|roots|rootDir|projects)$/;
 function spreadsIntoConfig(node, runner) {
   const obj = node.parent;
-  if (!ts3.isObjectLiteralExpression(obj)) return false;
-  const keys = obj.properties.map((p) => ts3.isPropertyAssignment(p) ? keyName2(p.name) : null);
+  if (!ts4.isObjectLiteralExpression(obj)) return false;
+  const keys = obj.properties.map((p) => ts4.isPropertyAssignment(p) ? keyName2(p.name) : null);
   if (runner === "vitest") {
     if (keys.includes("test")) return true;
     let q = obj.parent;
-    while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
-    return !!q && ts3.isPropertyAssignment(q) && keyName2(q.name) === "test";
+    while (q && (ts4.isParenthesizedExpression(q) || ts4.isAsExpression(q) || q.kind === ts4.SyntaxKind.SatisfiesExpression)) q = q.parent;
+    return !!q && ts4.isPropertyAssignment(q) && keyName2(q.name) === "test";
   }
   return keys.some((k) => k !== null && JEST_SELECTION_KEYS.test(k));
 }
 function extendsOf(el) {
   for (const p of el.properties) {
-    if (!ts3.isPropertyAssignment(p) || keyName2(p.name) !== "extends") continue;
-    if (p.initializer.kind === ts3.SyntaxKind.TrueKeyword) return true;
-    if (p.initializer.kind === ts3.SyntaxKind.FalseKeyword) return null;
+    if (!ts4.isPropertyAssignment(p) || keyName2(p.name) !== "extends") continue;
+    if (p.initializer.kind === ts4.SyntaxKind.TrueKeyword) return true;
+    if (p.initializer.kind === ts4.SyntaxKind.FalseKeyword) return null;
     return "path";
   }
   return null;
@@ -5461,14 +5819,14 @@ function readProject(el, root, runner) {
   return p;
 }
 function readProjects(e, root, runner) {
-  if (!ts3.isArrayLiteralExpression(e)) {
+  if (!ts4.isArrayLiteralExpression(e)) {
     root.opaque = true;
     return [];
   }
   const list2 = [];
   for (const el of e.elements) {
     const lit = unwrapConfigCall(el);
-    if (ts3.isObjectLiteralExpression(lit)) list2.push(readProject(lit, root, runner));
+    if (ts4.isObjectLiteralExpression(lit)) list2.push(readProject(lit, root, runner));
     else root.opaque = true;
   }
   return list2;
@@ -5476,14 +5834,14 @@ function readProjects(e, root, runner) {
 function workspaceArray(sf) {
   for (const st of sf.statements) {
     let e;
-    if (ts3.isExportAssignment(st)) e = st.expression;
-    else if (ts3.isExpressionStatement(st) && ts3.isBinaryExpression(st.expression) && /module\.exports/.test(st.expression.left.getText())) e = st.expression.right;
+    if (ts4.isExportAssignment(st)) e = st.expression;
+    else if (ts4.isExpressionStatement(st) && ts4.isBinaryExpression(st.expression) && /module\.exports/.test(st.expression.left.getText())) e = st.expression.right;
     if (!e) continue;
-    while (ts3.isParenthesizedExpression(e) || ts3.isAsExpression(e) || e.kind === ts3.SyntaxKind.SatisfiesExpression) {
+    while (ts4.isParenthesizedExpression(e) || ts4.isAsExpression(e) || e.kind === ts4.SyntaxKind.SatisfiesExpression) {
       e = e.expression;
     }
-    if (ts3.isCallExpression(e) && e.arguments.length > 0) e = e.arguments[0];
-    return ts3.isArrayLiteralExpression(e) ? e : null;
+    if (ts4.isCallExpression(e) && e.arguments.length > 0) e = e.arguments[0];
+    return ts4.isArrayLiteralExpression(e) ? e : null;
   }
   return null;
 }
@@ -5491,7 +5849,7 @@ function parseSelection(src, runner, path = "") {
   let sel = empty();
   if (runner === "pytest") return pytestSelection(src);
   try {
-    const sf = ts3.createSourceFile("cfg.ts", asExpression2(src), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+    const sf = ts4.createSourceFile("cfg.ts", asExpression2(src), ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
     if (runner === "vitest" && isWorkspaceFile(path)) {
       const arr = workspaceArray(sf);
       if (arr) {
@@ -5598,21 +5956,21 @@ var TEST_DEFS = {
   cs: /^\s*\[(?:Fact|Theory|Test|TestMethod|TestCase|DataTestMethod)\b/
 };
 function calleeName(expr) {
-  if (ts4.isIdentifier(expr)) return expr.text;
-  if (ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression)) {
+  if (ts5.isIdentifier(expr)) return expr.text;
+  if (ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression)) {
     return expr.expression.text;
   }
   return null;
 }
 var TABLE_METHOD = /^(?:each|for)$/;
-var isEachOf = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && TABLE_METHOD.test(expr.name.text);
-var isDescribeEach = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && expr.expression.text === "describe" && TABLE_METHOD.test(expr.name.text);
+var isEachOf = (expr) => ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && TABLE_METHOD.test(expr.name.text);
+var isDescribeEach = (expr) => ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression) && expr.expression.text === "describe" && TABLE_METHOD.test(expr.name.text);
 function loopRows(iterable) {
-  if (ts4.isArrayLiteralExpression(iterable)) {
+  if (ts5.isArrayLiteralExpression(iterable)) {
     let n = 0;
     let open = false;
     for (const el of iterable.elements) {
-      if (ts4.isSpreadElement(el)) open = true;
+      if (ts5.isSpreadElement(el)) open = true;
       else n++;
     }
     return { n: Math.max(n, open ? 0 : 1), open };
@@ -5624,20 +5982,20 @@ function templateRows(node) {
   return Math.max(rows, 1);
 }
 function hasSubstantiveBody(call) {
-  const fn = call.arguments.find((a) => ts4.isArrowFunction(a) || ts4.isFunctionExpression(a));
+  const fn = call.arguments.find((a) => ts5.isArrowFunction(a) || ts5.isFunctionExpression(a));
   if (!fn) return true;
   const body = fn.body;
-  const text = ts4.isBlock(body) ? body.getText().slice(1, -1) : body.getText();
+  const text = ts5.isBlock(body) ? body.getText().slice(1, -1) : body.getText();
   return text.split("\n").some((l) => isSignificantLine(l.trim(), "js"));
 }
 function eachRows(call) {
   const arg = call.arguments[0];
   if (!arg) return { n: 1, open: true };
-  if (ts4.isArrayLiteralExpression(arg)) {
+  if (ts5.isArrayLiteralExpression(arg)) {
     let n = 0;
     let open = false;
     for (const el of arg.elements) {
-      if (ts4.isSpreadElement(el)) open = true;
+      if (ts5.isSpreadElement(el)) open = true;
       else n++;
     }
     return { n: Math.max(n, open ? 0 : 1), open };
@@ -5652,35 +6010,35 @@ function countTests(src, path = "spec.ts", substantiveOnly = false) {
     for (const line of src.split("\n")) if (re.test(line)) n2++;
     return { min: n2, open: false };
   }
-  const sf = ts4.createSourceFile("spec.ts", src, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const sf = ts5.createSourceFile("spec.ts", src, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
   let n = 0;
   let open = false;
   const visit = (node, mult) => {
-    if (ts4.isForOfStatement(node)) {
+    if (ts5.isForOfStatement(node)) {
       const r = loopRows(node.expression);
       if (r.open) open = true;
       visit(node.statement, mult * r.n);
       return;
     }
-    if (ts4.isForStatement(node) || ts4.isForInStatement(node) || ts4.isWhileStatement(node) || ts4.isDoStatement(node)) {
+    if (ts5.isForStatement(node) || ts5.isForInStatement(node) || ts5.isWhileStatement(node) || ts5.isDoStatement(node)) {
       open = true;
     }
-    if (ts4.isCallExpression(node)) {
+    if (ts5.isCallExpression(node)) {
       const callee = node.expression;
-      if (ts4.isPropertyAccessExpression(callee) && callee.name.text === "forEach") {
+      if (ts5.isPropertyAccessExpression(callee) && callee.name.text === "forEach") {
         const r = loopRows(callee.expression);
         if (r.open) open = true;
         for (const a of node.arguments) visit(a, mult * r.n);
         return;
       }
       const head = node.expression;
-      if (ts4.isCallExpression(head) && isDescribeEach(head.expression)) {
+      if (ts5.isCallExpression(head) && isDescribeEach(head.expression)) {
         const r = eachRows(head);
         if (r.open) open = true;
         for (const a of node.arguments) visit(a, mult * r.n);
         return;
       }
-      if (ts4.isTaggedTemplateExpression(head) && isDescribeEach(head.tag)) {
+      if (ts5.isTaggedTemplateExpression(head) && isDescribeEach(head.tag)) {
         for (const a of node.arguments) visit(a, mult * templateRows(head));
         return;
       }
@@ -5692,10 +6050,10 @@ function countTests(src, path = "spec.ts", substantiveOnly = false) {
         const name = calleeName(node.expression);
         if ((name === "it" || name === "test") && (!substantiveOnly || hasSubstantiveBody(node))) n += mult;
       }
-    } else if (ts4.isTaggedTemplateExpression(node) && isEachOf(node.tag)) {
+    } else if (ts5.isTaggedTemplateExpression(node) && isEachOf(node.tag)) {
       n += templateRows(node) * mult;
     }
-    ts4.forEachChild(node, (c) => visit(c, mult));
+    ts5.forEachChild(node, (c) => visit(c, mult));
   };
   visit(sf, 1);
   return { min: n, open };
@@ -5997,7 +6355,7 @@ function pytestPrecedenceFindings(changes, policy, ctx) {
 }
 
 // src/detectors/test-content-removal.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 var RULE8 = "test-content-removal";
 var MIN_REMOVED_LINES = 3;
 var MIN_REMOVED_ROWS = 2;
@@ -6007,13 +6365,13 @@ function eachTables(src, path) {
   let open = false;
   if (langOf(path) !== "js" && langOf(path) !== null) return { rows, open };
   try {
-    const sf = ts5.createSourceFile("spec.ts", src, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
+    const sf = ts6.createSourceFile("spec.ts", src, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
     const visit = (node) => {
-      if (ts5.isCallExpression(node) && ts5.isPropertyAccessExpression(node.expression) && /^(?:each|for)$/.test(node.expression.name.text) && ts5.isIdentifier(node.expression.expression) && /^(?:it|test|describe)$/.test(node.expression.expression.text)) {
+      if (ts6.isCallExpression(node) && ts6.isPropertyAccessExpression(node.expression) && /^(?:each|for)$/.test(node.expression.name.text) && ts6.isIdentifier(node.expression.expression) && /^(?:it|test|describe)$/.test(node.expression.expression.text)) {
         const arg = node.arguments[0];
-        if (arg && ts5.isArrayLiteralExpression(arg)) {
+        if (arg && ts6.isArrayLiteralExpression(arg)) {
           for (const el of arg.elements) {
-            if (ts5.isSpreadElement(el)) {
+            if (ts6.isSpreadElement(el)) {
               open = true;
               continue;
             }
@@ -6023,7 +6381,7 @@ function eachTables(src, path) {
           }
         } else open = true;
       }
-      ts5.forEachChild(node, visit);
+      ts6.forEachChild(node, visit);
     };
     visit(sf);
   } catch {
@@ -6202,7 +6560,7 @@ var snapshotOnlyRewrite = {
 };
 
 // src/detectors/assertion-weakening.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 var RULE11 = "assertion-weakening";
 var TEST_CALLS = /* @__PURE__ */ new Set(["it", "test"]);
 var SUITE_CALLS = /* @__PURE__ */ new Set(["describe", "suite", "context"]);
@@ -6211,55 +6569,55 @@ var WEAK_MATCHERS = /* @__PURE__ */ new Set(["toBeTruthy", "toBeDefined"]);
 var compact = (s) => s.replace(/\s+/g, "");
 function literalTitle(node) {
   if (!node) return null;
-  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts7.isStringLiteral(node) || ts7.isNoSubstitutionTemplateLiteral(node)) return node.text;
   return null;
 }
 function scriptKindForPath(path) {
   const lower = path.toLowerCase();
-  if (lower.endsWith(".tsx")) return ts6.ScriptKind.TSX;
+  if (lower.endsWith(".tsx")) return ts7.ScriptKind.TSX;
   if (lower.endsWith(".ts") || lower.endsWith(".mts") || lower.endsWith(".cts")) {
-    return ts6.ScriptKind.TS;
+    return ts7.ScriptKind.TS;
   }
-  if (lower.endsWith(".jsx")) return ts6.ScriptKind.JSX;
-  return ts6.ScriptKind.JS;
+  if (lower.endsWith(".jsx")) return ts7.ScriptKind.JSX;
+  return ts7.ScriptKind.JS;
 }
 function staticFacts(node) {
   if (!node) return null;
-  if (node.kind === ts6.SyntaxKind.TrueKeyword) return { defined: true, truthy: true };
-  if (node.kind === ts6.SyntaxKind.FalseKeyword) return { defined: true, truthy: false };
-  if (node.kind === ts6.SyntaxKind.NullKeyword) return { defined: true, truthy: false };
-  if (ts6.isIdentifier(node) && node.text === "undefined") {
+  if (node.kind === ts7.SyntaxKind.TrueKeyword) return { defined: true, truthy: true };
+  if (node.kind === ts7.SyntaxKind.FalseKeyword) return { defined: true, truthy: false };
+  if (node.kind === ts7.SyntaxKind.NullKeyword) return { defined: true, truthy: false };
+  if (ts7.isIdentifier(node) && node.text === "undefined") {
     return { defined: false, truthy: false };
   }
-  if (ts6.isVoidExpression(node)) return { defined: false, truthy: false };
-  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts7.isVoidExpression(node)) return { defined: false, truthy: false };
+  if (ts7.isStringLiteral(node) || ts7.isNoSubstitutionTemplateLiteral(node)) {
     return { defined: true, truthy: node.text.length > 0 };
   }
-  if (ts6.isNumericLiteral(node)) {
+  if (ts7.isNumericLiteral(node)) {
     return { defined: true, truthy: Number(node.text) !== 0 };
   }
-  if (ts6.isBigIntLiteral(node)) {
+  if (ts7.isBigIntLiteral(node)) {
     return { defined: true, truthy: node.text.replace(/n$/i, "") !== "0" };
   }
-  if (ts6.isPrefixUnaryExpression(node) && (node.operator === ts6.SyntaxKind.MinusToken || node.operator === ts6.SyntaxKind.PlusToken) && ts6.isNumericLiteral(node.operand)) {
-    const value = Number(node.operand.text) * (node.operator === ts6.SyntaxKind.MinusToken ? -1 : 1);
+  if (ts7.isPrefixUnaryExpression(node) && (node.operator === ts7.SyntaxKind.MinusToken || node.operator === ts7.SyntaxKind.PlusToken) && ts7.isNumericLiteral(node.operand)) {
+    const value = Number(node.operand.text) * (node.operator === ts7.SyntaxKind.MinusToken ? -1 : 1);
     return { defined: true, truthy: value !== 0 };
   }
-  if (ts6.isObjectLiteralExpression(node) || ts6.isArrayLiteralExpression(node) || ts6.isRegularExpressionLiteral(node) || ts6.isArrowFunction(node) || ts6.isFunctionExpression(node) || ts6.isClassExpression(node) || ts6.isNewExpression(node)) {
+  if (ts7.isObjectLiteralExpression(node) || ts7.isArrayLiteralExpression(node) || ts7.isRegularExpressionLiteral(node) || ts7.isArrowFunction(node) || ts7.isFunctionExpression(node) || ts7.isClassExpression(node) || ts7.isNewExpression(node)) {
     return { defined: true, truthy: true };
   }
   return null;
 }
 function expectAssertion(node, sf) {
-  if (!ts6.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts7.isPropertyAccessExpression(node.expression)) return null;
   const matcher = node.expression.name.text;
   let receiver = node.expression.expression;
   let polarity = "";
-  if (ts6.isPropertyAccessExpression(receiver) && receiver.name.text === "not") {
+  if (ts7.isPropertyAccessExpression(receiver) && receiver.name.text === "not") {
     polarity = "not";
     receiver = receiver.expression;
   }
-  if (!ts6.isCallExpression(receiver) || !ts6.isIdentifier(receiver.expression) || receiver.expression.text !== "expect" || receiver.arguments.length !== 1) {
+  if (!ts7.isCallExpression(receiver) || !ts7.isIdentifier(receiver.expression) || receiver.expression.text !== "expect" || receiver.arguments.length !== 1) {
     return null;
   }
   const subject = compact(receiver.arguments[0].getText(sf));
@@ -6275,41 +6633,41 @@ function expectAssertion(node, sf) {
   };
 }
 function simpleCallName(node) {
-  return ts6.isIdentifier(node.expression) ? node.expression.text : null;
+  return ts7.isIdentifier(node.expression) ? node.expression.text : null;
 }
 function callbackFor(node) {
   const cb = node.arguments[1];
-  return cb && (ts6.isArrowFunction(cb) || ts6.isFunctionExpression(cb)) ? cb : null;
+  return cb && (ts7.isArrowFunction(cb) || ts7.isFunctionExpression(cb)) ? cb : null;
 }
 function blocks(src, path) {
   const out2 = /* @__PURE__ */ new Map();
   if (langOf(path) !== "js") return out2;
   try {
-    const sf = ts6.createSourceFile(path, src, ts6.ScriptTarget.Latest, true, scriptKindForPath(path));
+    const sf = ts7.createSourceFile(path, src, ts7.ScriptTarget.Latest, true, scriptKindForPath(path));
     const visit = (node, suites) => {
-      if (ts6.isCallExpression(node)) {
+      if (ts7.isCallExpression(node)) {
         const call = simpleCallName(node);
         const title = literalTitle(node.arguments[0]);
         const cb = callbackFor(node);
         if (call && SUITE_CALLS.has(call) && title !== null && cb) {
           const nextSuites = [...suites, title];
-          ts6.forEachChild(cb, (child) => visit(child, nextSuites));
+          ts7.forEachChild(cb, (child) => visit(child, nextSuites));
           return;
         }
         if (call && TEST_CALLS.has(call) && title !== null && cb) {
           const assertions = [];
           const collect2 = (child) => {
-            if (child !== cb && ts6.isCallExpression(child)) {
+            if (child !== cb && ts7.isCallExpression(child)) {
               const nestedCall = simpleCallName(child);
               if (nestedCall && (TEST_CALLS.has(nestedCall) || SUITE_CALLS.has(nestedCall))) {
                 return;
               }
             }
-            if (ts6.isCallExpression(child)) {
+            if (ts7.isCallExpression(child)) {
               const a = expectAssertion(child, sf);
               if (a) assertions.push(a);
             }
-            ts6.forEachChild(child, collect2);
+            ts7.forEachChild(child, collect2);
           };
           collect2(cb);
           const identity2 = [...suites, title].join(" > ");
@@ -6319,7 +6677,7 @@ function blocks(src, path) {
           return;
         }
       }
-      ts6.forEachChild(node, (child) => visit(child, suites));
+      ts7.forEachChild(node, (child) => visit(child, suites));
     };
     visit(sf, []);
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.17.0",
+  "version": "2.17.1",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",