@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/utils/pathMatching.js

@@ -49,7 +49,8 @@ export const isBareIdPath = (path) => {
     return (segs.length > 0 &&
         segs.every((seg) => {
             const canonical = canonicalSegment(seg);
-            return canonical.startsWith("{") && canonical.slice(1, -1).toLowerCase() === "id";
+            return (canonical.startsWith("{") &&
+                canonical.slice(1, -1).toLowerCase() === "id");
         }));
 };
 // Segment-boundary suffix match: avoids "/orders" matching "/preorders".

package/build/utils/pathSignatures.js

@@ -27,7 +27,9 @@ export function buildPathSignatures(file) {
     // import of "./Foo" — special-case the compound extension.
     const isDts = /\.d\.ts$/i.test(file);
     const ext = isDts ? ".d.ts" : path.extname(file);
-    const basename = isDts ? path.basename(file, ".d.ts") : path.basename(file, ext);
+    const basename = isDts
+        ? path.basename(file, ".d.ts")
+        : path.basename(file, ext);
     const quotes = [`'`, `"`, "`"];
     const stems = [`/${basename}`, `/${basename}${ext}`];
     // An index module is normally imported by its directory (`from './_constants'`,
@@ -43,7 +45,9 @@ export function buildPathSignatures(file) {
 /** True for `index.<ext>` modules, including `index.d.ts` (the same test buildPathSignatures uses). */
 export function isIndexModule(file) {
     const isDts = /\.d\.ts$/i.test(file);
-    return (isDts ? path.basename(file, ".d.ts") : path.basename(file, path.extname(file))) === "index";
+    return ((isDts
+        ? path.basename(file, ".d.ts")
+        : path.basename(file, path.extname(file))) === "index");
 }
 /**
  * True when `importerContent` (the source of `importerFile`) contains an import

package/build/utils/planMatchKeys.d.ts

@@ -11,7 +11,7 @@
  *    matching (contract tests, or a fallback when names drift between
  *    register and generate).
  */
-import { PlanScenario } from "../types/RepositoryAnalysis.js";
+import { PlannedScenario } from "../recommendation/types.js";
 import type { PlannedTest } from "../recommendation/types.js";
 /** Query shape built from a generation-tool call or a reported test entry. */
 export interface PlanMatchQuery {
@@ -34,7 +34,7 @@ export declare function normalizeMatchPath(rawPath: string | undefined): string;
 /** Name key (if a name exists) plus one endpoint key per step. BOTH kinds carry
  *  the planned test's test type, or a contract call matches an integration-only
  *  planned test sharing its name. A slug holds no `:`. */
-export declare function computeMatchKeys(scenario: PlanScenario): string[];
+export declare function computeMatchKeys(scenario: PlannedScenario): string[];
 /**
  * True when `query` matches `keys`:
  *  - by testType + scenarioName slug (`name:<testType>:<slug>`), or

package/build/utils/planMatchKeys.js

@@ -51,7 +51,9 @@ export function isOpaqueIdSegment(segment) {
     // The sign belongs to the value: an edge-case step writes `/orders/-1` to
     // probe a negative id, and without the sign that segment became the resource
     // name, so the key could never match real order coverage.
-    return UUID_RE.test(segment) || /^-?\d+$/.test(segment) || /^[0-9a-f]{16,}$/i.test(segment);
+    return (UUID_RE.test(segment) ||
+        /^-?\d+$/.test(segment) ||
+        /^[0-9a-f]{16,}$/i.test(segment));
 }
 /**
  * Normalize a path so param and id segments collapse to `:p`.
@@ -76,22 +78,20 @@ export function normalizeMatchPath(rawPath) {
     })
         .join("/");
 }
-/** The scenario is read back from the stored plan, so `steps` is an array only on
- *  the validated path. `?? []` keeps a malformed plan from costing the call. */
-function inferTestType(scenario) {
-    const steps = Array.isArray(scenario?.steps) ? scenario.steps : [];
-    return (scenario?.testType ?? (steps.length === 1 ? "contract" : "integration")).toLowerCase();
-}
 /** Name key (if a name exists) plus one endpoint key per step. BOTH kinds carry
  *  the planned test's test type, or a contract call matches an integration-only
  *  planned test sharing its name. A slug holds no `:`. */
 export function computeMatchKeys(scenario) {
     const keys = [];
-    const testType = inferTestType(scenario);
-    const slug = slugifyName(scenario?.scenarioName);
+    const testType = scenario.testType.toLowerCase();
+    const slug = slugifyName(scenario.scenarioName);
     if (slug)
         keys.push(`name:${testType}:${slug}`);
-    for (const step of Array.isArray(scenario?.steps) ? scenario.steps : []) {
+    // The steps come back off the run state file too, so the array the type declares
+    // holds only on the validated path. A corrupted one is no evidence about the
+    // scenario, and a throw here failed generation instead of allowing the call.
+    const steps = Array.isArray(scenario.steps) ? scenario.steps : [];
+    for (const step of steps) {
         if (!step?.method || !step?.path)
             continue;
         keys.push(`ep:${testType}:${step.method.toUpperCase()}:${normalizeMatchPath(step.path)}`);
@@ -127,8 +127,12 @@ function nameAgrees(keys, query) {
     const nameSlug = query.scenarioName ? slugifyName(query.scenarioName) : "";
     if (!nameSlug)
         return false;
-    const wanted = query.testType ? `name:${query.testType.toLowerCase()}:${nameSlug}` : undefined;
-    return keys.some((key) => wanted !== undefined ? key === wanted : key.startsWith("name:") && key.endsWith(`:${nameSlug}`));
+    const wanted = query.testType
+        ? `name:${query.testType.toLowerCase()}:${nameSlug}`
+        : undefined;
+    return keys.some((key) => wanted !== undefined
+        ? key === wanted
+        : key.startsWith("name:") && key.endsWith(`:${nameSlug}`));
 }
 /** Whether the plan holds this query's endpoint, ignoring the name. Shared by
  *  the name channel — which may no longer answer alone on an endpoint query —
@@ -222,12 +226,14 @@ export function nameMatchedTypeMismatches(plannedTests, query) {
         // The name channel, minus the type: a key ending in this slug means the plan
         // holds the scenario, and the segment before it is the type it holds it as.
         const named = keys.filter((key) => key.startsWith("name:") && key.endsWith(`:${nameSlug}`));
-        return named.length > 0 && !named.some((key) => key === `name:${calledType}:${nameSlug}`);
+        return (named.length > 0 &&
+            !named.some((key) => key === `name:${calledType}:${nameSlug}`));
     });
 }
 /** True when `query` matches at least one planned test of the registered plan.
  *  The keys are computed per call rather than stored with the plan, so there is
  *  one description of a planned test and no second shape to drift from it. */
 export function matchesPlanCandidates(plannedTests, query) {
-    return plannedTests.some((plannedTest) => !!plannedTest?.scenario && matchesMatchKeys(computeMatchKeys(plannedTest.scenario), query));
+    return plannedTests.some((plannedTest) => !!plannedTest?.scenario &&
+        matchesMatchKeys(computeMatchKeys(plannedTest.scenario), query));
 }

package/build/utils/pom-catalog-parse.js

@@ -36,7 +36,9 @@ function selectorsFrom(description) {
         }
         // A bare token is only a selector if the whole backticked run is one — otherwise
         // it is prose, or an attribute selector already harvested above.
-        if (!sawAttr && BARE_TOKEN_RE.test(token) && token.length >= MIN_BARE_TOKEN_LENGTH) {
+        if (!sawAttr &&
+            BARE_TOKEN_RE.test(token) &&
+            token.length >= MIN_BARE_TOKEN_LENGTH) {
             out.add(token);
         }
     }
@@ -125,7 +127,10 @@ function bareMemberName(member) {
  */
 export function findMissedReuse(specContent, members) {
     const locators = extractRawLocatorTokens(specContent);
-    const compiled = members.map((m) => ({ m, matchers: m.selectors.map(toMatcher) }));
+    const compiled = members.map((m) => ({
+        m,
+        matchers: m.selectors.map(toMatcher),
+    }));
     const missed = [];
     for (const locator of locators) {
         const hit = compiled.find(({ matchers }) => matchers.some((re) => re.test(locator)));

package/build/utils/pom-scope/import-expansion.js

@@ -19,7 +19,12 @@ export async function expandImports(selected, allPoms) {
             if (!ref || !ref.startsWith("."))
                 continue;
             const base = path.resolve(path.dirname(file), ref);
-            for (const cand of [base, `${base}.js`, `${base}.ts`, base.replace(/\.js$/, ".ts")]) {
+            for (const cand of [
+                base,
+                `${base}.js`,
+                `${base}.ts`,
+                base.replace(/\.js$/, ".ts"),
+            ]) {
                 if (pomSet.has(cand) && !seen.has(cand)) {
                     seen.add(cand);
                     out.push({ file: cand, referrer: file });

package/build/utils/pom-scope/index.js

@@ -1,6 +1,6 @@
 import { readFile, stat } from "fs/promises";
 import * as path from "path";
-import { extractSelectors, DEFAULT_TESTID_ATTRS } from "./selector-extractor.js";
+import { extractSelectors, DEFAULT_TESTID_ATTRS, } from "./selector-extractor.js";
 import { globPomFiles, globAllSourceFiles } from "./pom-files.js";
 import { scorePoms } from "./scoring.js";
 import { expandImports } from "./import-expansion.js";
@@ -9,17 +9,29 @@ import { stripComments } from "./strip.js";
 const DISCOVERY_FILE_CAP = 3000;
 export const SELECTION_CAP = 10;
 export const FINAL_CAP = 25;
-const PLAYWRIGHT_CONFIG_NAMES = ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs", "playwright.config.cjs"];
+const PLAYWRIGHT_CONFIG_NAMES = [
+    "playwright.config.ts",
+    "playwright.config.js",
+    "playwright.config.mjs",
+    "playwright.config.cjs",
+];
 const TESTID_ATTRIBUTE_RE = /testIdAttribute\s*:\s*["']([^"']+)["']/;
 export async function findRoot(startDir) {
     let dir = startDir;
     for (let i = 0; i < 8; i++) {
-        for (const marker of ["package.json", "tsconfig.json", "jsconfig.json", ".git"]) {
+        for (const marker of [
+            "package.json",
+            "tsconfig.json",
+            "jsconfig.json",
+            ".git",
+        ]) {
             try {
                 await stat(path.join(dir, marker));
                 return dir;
             }
-            catch { /* keep walking */ }
+            catch {
+                /* keep walking */
+            }
         }
         const parent = path.dirname(dir);
         if (parent === dir)
@@ -39,7 +51,9 @@ export async function readTestIdAttribute(root) {
             if (m)
                 return m[1];
         }
-        catch { /* try next filename */ }
+        catch {
+            /* try next filename */
+        }
     }
     return undefined;
 }
@@ -49,7 +63,9 @@ export async function readTestIdAttribute(root) {
  * the exact-tie case in index.test.ts.
  */
 export function tierAndCap(candidates, maxScore) {
-    const kept = [...candidates].sort((a, b) => b.score - a.score).slice(0, FINAL_CAP);
+    const kept = [...candidates]
+        .sort((a, b) => b.score - a.score)
+        .slice(0, FINAL_CAP);
     const isTier1 = (c) => c.score > maxScore / 4 || c.rareHits >= 2;
     const tier1 = kept.filter(isTier1);
     const tier2 = kept.filter((c) => !isTier1(c));
@@ -57,16 +73,24 @@ export function tierAndCap(candidates, maxScore) {
 }
 /** Deterministic POM pre-scoping. tier1/tier2 both [] ⇒ caller must fall back to the unscoped prompt. */
 export async function selectScopedPoms(opts) {
-    const empty = (selectors = 0, pomFiles = 0, discovery = "none") => ({ tier1: [], tier2: [], diagnostics: { selectors, pomFiles, scoped: 0, discovery } });
+    const empty = (selectors = 0, pomFiles = 0, discovery = "none") => ({
+        tier1: [],
+        tier2: [],
+        diagnostics: { selectors, pomFiles, scoped: 0, discovery },
+    });
     let spec = opts.specContent ?? "";
     // Prefer the on-disk file (the agent may have rewritten it); fall back to the passed prompt content.
     try {
         spec = await readFile(opts.testFile, "utf8");
     }
-    catch { /* use provided specContent */ }
+    catch {
+        /* use provided specContent */
+    }
     const root = await findRoot(path.dirname(opts.testFile));
     const testIdAttribute = await readTestIdAttribute(root);
-    const extraTestIdAttrs = testIdAttribute && !DEFAULT_TESTID_ATTRS.includes(testIdAttribute) ? [testIdAttribute] : [];
+    const extraTestIdAttrs = testIdAttribute && !DEFAULT_TESTID_ATTRS.includes(testIdAttribute)
+        ? [testIdAttribute]
+        : [];
     const selectors = extractSelectors(spec, extraTestIdAttrs);
     if (selectors.length === 0)
         return empty();
@@ -111,19 +135,33 @@ export async function selectScopedPoms(opts) {
     const candidates = expanded.flatMap(({ file, referrer }) => {
         const own = rankedByFile.get(file);
         if (own)
-            return [{ file: own.file, score: own.score, rareHits: own.rareHits, matchedTokens: own.matchedTokens }];
+            return [
+                {
+                    file: own.file,
+                    score: own.score,
+                    rareHits: own.rareHits,
+                    matchedTokens: own.matchedTokens,
+                },
+            ];
         // Invariant: every expansion addition without an own rank carries the referrer that
         // pulled it in (expandImports always tags non-selected files this way). Skip
         // defensively rather than assert, in case that invariant is ever violated.
         const referrerEntry = referrer ? rankedByFile.get(referrer) : undefined;
         if (!referrerEntry)
             return [];
-        return [{ file, score: referrerEntry.score, rareHits: 0, matchedTokens: [] }];
+        return [
+            { file, score: referrerEntry.score, rareHits: 0, matchedTokens: [] },
+        ];
     });
     const { tier1, tier2 } = tierAndCap(candidates, maxScore);
     return {
         tier1,
         tier2,
-        diagnostics: { selectors: selectors.length, pomFiles: pomFiles.length, scoped: tier1.length + tier2.length, discovery },
+        diagnostics: {
+            selectors: selectors.length,
+            pomFiles: pomFiles.length,
+            scoped: tier1.length + tier2.length,
+            discovery,
+        },
     };
 }

package/build/utils/pom-scope/scoring.js

@@ -20,12 +20,16 @@ export async function scorePoms(selectors, files) {
         try {
             contents.set(f, (await readFile(f, "utf8")).replace(/\\/g, ""));
         }
-        catch { /* unreadable file: skip */ }
+        catch {
+            /* unreadable file: skip */
+        }
     }));
     // Selectors arrive pre-normalized from extractSelectors — only file contents need stripping.
     const fileMatches = new Map(); // selector -> files containing it
     for (const sel of selectors) {
-        const matched = [...contents.entries()].filter(([, c]) => c.includes(sel)).map(([f]) => f);
+        const matched = [...contents.entries()]
+            .filter(([, c]) => c.includes(sel))
+            .map(([f]) => f);
         if (matched.length > 0)
             fileMatches.set(sel, matched);
     }
@@ -33,7 +37,13 @@ export async function scorePoms(selectors, files) {
     for (const [sel, matched] of fileMatches) {
         const df = matched.length;
         for (const f of matched) {
-            const s = scores.get(f) ?? { file: f, score: 0, hits: 0, rareHits: 0, matchedTokens: [] };
+            const s = scores.get(f) ?? {
+                file: f,
+                score: 0,
+                hits: 0,
+                rareHits: 0,
+                matchedTokens: [],
+            };
             s.score += 1 / df;
             s.hits += 1;
             if (df <= RARE_DF)

package/build/utils/pom-scope/selector-extractor.js

@@ -5,7 +5,12 @@
  */
 // Default test-id attribute family. Playwright's own default is data-testid, but
 // data-test/data-qa/data-cy are common conventions in the wild — match them all.
-export const DEFAULT_TESTID_ATTRS = ["data-test", "data-testid", "data-qa", "data-cy"];
+export const DEFAULT_TESTID_ATTRS = [
+    "data-test",
+    "data-testid",
+    "data-qa",
+    "data-cy",
+];
 // Full regex-escape for attr names — a config-supplied testIdAttribute could contain
 // a stray metachar, which must not be allowed to distort the pattern.
 import { escapeRegExp as esc } from "../regex.js";
@@ -20,7 +25,10 @@ const attrAnchor = (attrs) => new RegExp(`\\[(?:${attrs.map(esc).join("|")})[$^*
 // locator values, shared by both extractSelectors and extractRawLocatorTokens.
 const GET_BY_TEST_ID = /getByTestId\(\s*["']([^"']+)["']/g;
 const GET_BY_TEXT_LABEL_PLACEHOLDER = /getBy(?:Text|Label|Placeholder)\(\s*["']([^"']+)["']/g;
-const LOCATOR_PATTERNS = [GET_BY_TEST_ID, GET_BY_TEXT_LABEL_PLACEHOLDER];
+const LOCATOR_PATTERNS = [
+    GET_BY_TEST_ID,
+    GET_BY_TEXT_LABEL_PLACEHOLDER,
+];
 // getByRole("role", ...) and bare `name: "..."` object keys are useful evidence for
 // POM *detection* (scoring which page objects a test's actions touch), but they are
 // NOT raw locator values: a role name isn't a selector, and `name:` matches ANY bare
@@ -28,7 +36,12 @@ const LOCATOR_PATTERNS = [GET_BY_TEST_ID, GET_BY_TEXT_LABEL_PLACEHOLDER];
 // finding 1). Only extractSelectors (the detection path) includes these.
 const GET_BY_ROLE = /getByRole\(\s*["']([^"']+)["']/g;
 const BARE_NAME_FIELD = /name:\s*["']([^"']+)["']/g;
-const OTHER_PATTERNS = [GET_BY_TEST_ID, GET_BY_ROLE, BARE_NAME_FIELD, GET_BY_TEXT_LABEL_PLACEHOLDER];
+const OTHER_PATTERNS = [
+    GET_BY_TEST_ID,
+    GET_BY_ROLE,
+    BARE_NAME_FIELD,
+    GET_BY_TEXT_LABEL_PLACEHOLDER,
+];
 // Raw .locator("...")/.frameLocator("...") strings that are NOT test-id-attribute based
 // (e.g. ".step-deduplication", "iframe#asset-list").
 // Quote-type-aware alternates: a double-quoted arg may contain unescaped single quotes

package/build/utils/pom-scope/strip.d.ts

@@ -1,3 +1,11 @@
+/** Every line- and block-comment span in `src`, in source order. Exported for callers
+ * that must decide whether a `//` OPENS a comment rather than sits inside one: a `//`
+ * on its own line inside `/* … *\/` opens nothing, and deleting that line can take the
+ * block's terminator with it. */
+export declare function commentSpans(src: string): {
+    start: number;
+    end: number;
+}[];
 /** Blanks line/block comments only, preserving string/template literal contents (e.g. so an
  * import specifier's quoted path stays readable). Each blanked character becomes a space
  * (newlines preserved) so remaining code characters keep their original offset. */

package/build/utils/pom-scope/strip.js

@@ -1,3 +1,195 @@
+/**
+ * Whether a `/` at `i` opens a regex literal rather than a division.
+ *
+ * The standard heuristic: a regex may only start where a VALUE may start, so the last
+ * significant character before it decides. `a / b` is division; `= /x/`, `( /x/`,
+ * `return /x/` are regex literals. A regex is not an edge case for these scanners —
+ * `/https:\/\//` holds `//`, and a lexer that does not know the literal reads that as
+ * the start of a comment and blanks the rest of the line.
+ */
+/** Whether position `k` falls inside a span the lexer already classified — a string, a
+ *  comment or a regex. Every span before the current position is complete, so this is
+ *  the state every backward look must consult. A quoted `)`, a `*\/` and a comment
+ *  between a keyword and its value each defeated one of the three looks below. */
+/** Every keyword a value may follow, so a `/` after one opens a regex and a `{` after
+ *  one opens an object literal. `throw /[/*]/` is the form that reads naturally in a
+ *  test file; without it the `/*` inside the character class opened a block comment
+ *  and blanked the rest of the file. */
+const VALUE_KEYWORDS = [
+    "return",
+    "throw",
+    "typeof",
+    "void",
+    "delete",
+    "instanceof",
+    "new",
+    "case",
+    "default",
+    "in",
+    "of",
+    "do",
+    "else",
+    "yield",
+    "await",
+];
+/** A `{` after one of these opens a BLOCK, never an object literal. They are in the
+ *  list above because a `/` after them opens a regex — `else /re/.test(v)` is valid —
+ *  and one list answering both questions read `else {}` as a value. */
+const BLOCK_KEYWORDS = ["else", "do"];
+/** The keyword token ending at `j`, or "" when the word there is not one.
+ *
+ *  A word after a `.` — or a `?.` — is a PROPERTY NAME, not a keyword: `obj.return`
+ *  and `it.return()` are ordinary member accesses, and reading them as the keyword
+ *  opened a regex at the division that follows, which then swallowed the first slash
+ *  of a trailing comment. Asked once, so the two keyword lookups below cannot drift.
+ */
+function keywordAt(src, j, done) {
+    const word = (src.slice(0, j + 1).match(/[A-Za-z_$][\w$]*$/) ?? [""])[0];
+    if (!word)
+        return "";
+    let k = j - word.length;
+    while (k >= 0 && (/\s/.test(src[k]) || triviaAt(done, k)))
+        k--;
+    return k >= 0 && src[k] === "." ? "" : word;
+}
+function spanAt(done, k) {
+    return done.find((s) => k >= s.start && k < s.end);
+}
+/** A comment is TRIVIA: the token before a `/` is whatever precedes the comment. A
+ *  string or a regex is a VALUE, so a `/` after one is a division — `"4" / 2` and
+ *  `/re/ / 2` both divide. Skipping every classified span read `= "4" /` as a regex
+ *  opener and swallowed the comment that followed. */
+function triviaAt(done, k) {
+    return spanAt(done, k)?.kind === "comment";
+}
+/** Structure only. A parenthesis inside a string, a comment or a regex is not part of
+ *  the balance: a quoted `)` in `if (check(")"))` hid the `if`. */
+function inertAt(done, k) {
+    return spanAt(done, k) !== undefined;
+}
+/** Whether the `)` at `close` ends the head of a control statement rather than a
+ *  call or a grouping. Matched back to its opening paren, then judged by the keyword
+ *  before it. */
+function closesControlHead(src, close, done) {
+    // Parentheses inside a string, a comment or a regex are not structure. They are
+    // already classified, because every span before this point is complete — a quoted
+    // `)` in `if (check(")"))` hid the `if` when the count read raw characters.
+    const inert = (k) => inertAt(done, k);
+    let depth = 0;
+    let k = close;
+    for (; k >= 0; k--) {
+        if (inert(k))
+            continue;
+        if (src[k] === ")")
+            depth++;
+        else if (src[k] === "(") {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+    }
+    if (k < 0)
+        return false;
+    // A comment sits between the keyword and its head as legally as whitespace does:
+    // `if /* note */ (ready)`. Both are skipped, or the `*\/` reads as the keyword.
+    let j = k - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    // Through the same question: `obj.if(ready)` is a call on a property, not a head.
+    const word = keywordAt(src, j, done);
+    return ["if", "while", "for", "with", "switch", "catch"].includes(word);
+}
+/** Whether the `}` at `close` ends an object literal rather than a block. Matched back
+ *  to its `{`, then judged by whether a VALUE could have started there. */
+function closesObjectLiteral(src, close, done) {
+    let depth = 0;
+    let k = close;
+    for (; k >= 0; k--) {
+        if (inertAt(done, k))
+            continue;
+        if (src[k] === "}")
+            depth++;
+        else if (src[k] === "{") {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+    }
+    if (k < 0)
+        return false;
+    let j = k - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    if (j < 0)
+        return false;
+    // `:` is DELIBERATELY absent, though `{ a: {} }` is an object literal. This
+    // function decides one thing — whether a `/` after the closing `}` divides — and
+    // the two wrong answers do not cost the same. Reading a regex where a division
+    // stands is bounded: a regex literal cannot cross a line, and an unterminated one
+    // is rejected. Reading a division where a regex stands lets a `/*` inside that
+    // regex open a block comment that runs to the end of the file. A colon introduces
+    // a statement label, a `case` clause and a `default` clause — all blocks, all of
+    // which a `/` may follow — so the safe answer is also the common one here. A
+    // division straight after a nested object literal is what it costs.
+    if ("=(,[!&|?+-*%~^<>".includes(src[j]))
+        return true;
+    // A keyword can introduce the value too: `return {}`, `yield {}`, `typeof {}`.
+    // Judging the matching `{` by the preceding CHARACTER alone missed every one of
+    // them, so `return {} / 2` read as a block and the slash opened a regex.
+    const word = keywordAt(src, j, done);
+    if (BLOCK_KEYWORDS.includes(word))
+        return false;
+    return VALUE_KEYWORDS.includes(word);
+}
+function opensRegex(src, i, done) {
+    let j = i - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    if (j < 0)
+        return true;
+    // A string or a regex ENDS here, so the slash divides its value.
+    if (spanAt(done, j)?.kind === "string")
+        return false;
+    const prev = src[j];
+    // `++` and `--` are POSTFIX here: `count++ / 2` is a division. Reading the `/` as a
+    // regex opener swallowed the rest of the line, so the line comment after it was
+    // never recognised — and a gate marker in that comment shipped unstripped.
+    if ((prev === "+" || prev === "-") && src[j - 1] === prev)
+        return false;
+    // JSX closes a tag with a slash, and a page object in a React repository is a `.tsx`
+    // file, so this is ordinary input. Both closing forms put the slash exactly where a
+    // value may start, so the heuristic opened a regex, terminated it on the first slash
+    // of the following comment, and left that comment unclassified — a marker in it
+    // shipped, and its text stayed readable to every scanner built on this file.
+    //
+    // ADJACENCY is what separates the two readings, so neither rule costs a real literal:
+    // JSX writes `</`, while a regex after a comparison is written `a < /re/`. `/>` is
+    // only re-read where the preceding `}` closes a JSX expression container — after `(`
+    // or `=` it stays the literal it is, so `s.split(/>/)` is untouched.
+    // Only a TAG NAME can follow the `</` of a closing tag — a letter, `_`, `$`, or the
+    // `>` of a fragment. A character that cannot start one means this is a regex written
+    // tight against a comparison: `a</[/*]/.test(v)` is valid, if unusual, JavaScript.
+    if (prev === "<" && j === i - 1 && /[A-Za-z_$>]/.test(src[i + 1] ?? ""))
+        return false;
+    if (prev === "}" && src[i + 1] === ">")
+        return false;
+    // A `}` closes a BLOCK, after which a statement — and so a regex — may start; or it
+    // closes an OBJECT LITERAL, which is a value, after which `/` divides. Decided by
+    // what precedes the matching `{`, the same way the control head is.
+    if (prev === "}")
+        return !closesObjectLiteral(src, j, done);
+    if ("=(,:[!&|?{;+-*%~^<>".includes(prev))
+        return true;
+    // A `)` usually ends a call, and `total(a) / 2` is a division. But the `)` that
+    // closes an `if (…)` head is followed by a STATEMENT, so a `/` after it opens a
+    // regex: `if (ready) /re/.test(v)`. Reading that as division let the `/*` inside a
+    // character class open a block comment and hide every later comment.
+    if (prev === ")" && closesControlHead(src, j, done))
+        return true;
+    // A keyword that takes a value next. `)` and an identifier character mean division.
+    const word = /[A-Za-z_$]/.test(prev) ? keywordAt(src, j, done) : "";
+    return VALUE_KEYWORDS.includes(word);
+}
 /**
  * Single lexer-lite pass over the source classifying every line comment, block comment, and
  * string/template literal span (escaped quotes handled; a template literal's `${...}`
@@ -27,6 +219,43 @@ function classifySpans(src) {
             spans.push({ kind: "comment", start, end: i });
             continue;
         }
+        // Classified as a string: the callers that blank strings want a regex's contents
+        // inert for the same reason, and the ones that blank comments must not touch it.
+        if (c === "/" && opensRegex(src, i, spans)) {
+            const start = i;
+            i++;
+            let inClass = false;
+            let closed = false;
+            while (i < n) {
+                const ch = src[i];
+                if (ch === "\\") {
+                    i += 2;
+                    continue;
+                }
+                // A regex literal cannot span a line. An unterminated one is not a literal.
+                if (ch === "\n")
+                    break;
+                if (ch === "[")
+                    inClass = true;
+                else if (ch === "]")
+                    inClass = false;
+                else if (ch === "/" && !inClass) {
+                    i++;
+                    closed = true;
+                    break;
+                }
+                i++;
+            }
+            if (!closed) {
+                i = start + 1;
+                continue;
+            }
+            // Trailing flags belong to the literal.
+            while (i < n && /[a-z]/.test(src[i]))
+                i++;
+            spans.push({ kind: "string", start, end: i });
+            continue;
+        }
         if (c === "'" || c === '"' || c === "`") {
             const quote = c;
             const start = i;
@@ -72,6 +301,15 @@ function blankSpans(src, spans) {
     }
     return out.join("");
 }
+/** Every line- and block-comment span in `src`, in source order. Exported for callers
+ * that must decide whether a `//` OPENS a comment rather than sits inside one: a `//`
+ * on its own line inside `/* … *\/` opens nothing, and deleting that line can take the
+ * block's terminator with it. */
+export function commentSpans(src) {
+    return classifySpans(src)
+        .filter((s) => s.kind === "comment")
+        .map(({ start, end }) => ({ start, end }));
+}
 /** Blanks line/block comments only, preserving string/template literal contents (e.g. so an
  * import specifier's quoted path stays readable). Each blanked character becomes a space
  * (newlines preserved) so remaining code characters keep their original offset. */

package/build/utils/pom-scope/testIdDiscovery.js

@@ -32,7 +32,16 @@ const ATTR_SELECTOR_RE = /\[\s*([A-Za-z][A-Za-z0-9_:-]*)\s*[~^$*|]?=\s*["']/g;
  * it admitted `data-auto-play` and `data-auto-height`, and `automation` already
  * covers the convention it was there for (`data-automation-id`).
  */
-const TEST_TOKENS = new Set(["test", "testid", "tests", "qa", "cy", "cypress", "e2e", "automation"]);
+const TEST_TOKENS = new Set([
+    "test",
+    "testid",
+    "tests",
+    "qa",
+    "cy",
+    "cypress",
+    "e2e",
+    "automation",
+]);
 /**
  * Whether a name plausibly denotes a test id.
  *
@@ -70,7 +79,10 @@ const OBSERVED_REPORT_LIMIT = 5;
 export async function discoverTestIdAttribute(root) {
     let files;
     try {
-        const [poms, specs] = await Promise.all([globPomFiles(root), globSpecFiles(root)]);
+        const [poms, specs] = await Promise.all([
+            globPomFiles(root),
+            globSpecFiles(root),
+        ]);
         files = [...new Set([...poms, ...specs])].slice(0, MAX_FILES);
     }
     catch {