@skyramp/mcp 0.4.2 → 0.4.3-rc.1

package/build/utils/utils-verify/parse.js

@@ -7,7 +7,7 @@ function actionSequence(body, language) {
     return keys ? { actionKey: keys.join("; "), actionSteps: keys } : {};
 }
 import { fixedSleepsIn, pythonSleepBindings, } from "./fixed-sleep.js";
-import { stripComments, stripCommentsAndStrings, stripStrings, } from "../pom-scope/strip.js";
+import { stringSpans, stripComments, stripCommentsAndStrings, stripStrings, } from "../pom-scope/strip.js";
 /** Whether the `<` at `i` opens a generic (`Record<string, …>`, `Array<{…}>`) rather
  *  than comparing (`i < 3`): a generic follows an identifier or `>` and is followed
  *  by a type start; a comparison is followed by a number, a space and a value, or
@@ -266,6 +266,7 @@ export function parseUtilsFile(content, spec) {
         const helper = {
             name,
             line: start + 1,
+            startLine: decoratorStart(lines, structure, start) + 1,
             endLine: Math.max(end, start + 1),
             wrapsRequest: false,
             hasGuard: hasPageErrorGuard(body.join("\n"), spec),
@@ -355,69 +356,100 @@ export function isSingleLiteral(line, m) {
         after.startsWith(")") ||
         after.startsWith("}"));
 }
-/** Comments and string CONTENTS blanked (quotes kept, line count preserved). Python
- *  comments are `#…`; TS/JS go through the shared stripper. */
-/** String CONTENTS blanked (quotes kept, comments kept, line count preserved). */
-export function blankStrings(src, spec) {
-    if (spec.language !== "python")
-        return stripStrings(src);
-    return blankPythonStrings(src);
+/** The string literals in `src`, quotes included, in order. TS/JS go through the
+ *  shared scanner; Python goes through the one below, so a caller sees one definition
+ *  of a literal for each language. */
+export function stringSpansOf(src, spec) {
+    return spec.language === "python" ? pythonStringSpans(src) : stringSpans(src);
 }
 /**
- * Blank every Python string literal, triple-quoted ones included, preserving offsets.
+ * The string literals in Python source, quotes included.
  *
- * A line-by-line regex cannot do this: a `"""…"""` block spans lines, so a `#` inside a
- * docstring or an embedded SQL block read as a comment. Every scanner built on this
- * then treated quoted text as code the file executes — and the delivery-time marker
- * strip deleted a line out of a value rather than out of a comment.
+ * Triple quotes are tested BEFORE single ones, and this is the whole reason the scan
+ * is not a regex: a `"""` read one quote at a time matches an empty `""` and leaves
+ * the payload to be treated as code. A multiline payload's own indentation is then
+ * read as formatting, and a change to it disappears.
+ *
+ * A single-quoted string that never closes before the end of its line is a stray
+ * apostrophe in code (`# don't`, or a regex), not an opener — the same rule the TS
+ * scanner applies. A prefix (`r`, `f`, `b`, `rb`) is code; only the quote opens the
+ * literal.
+ *
+ * COMMENTS ARE SKIPPED while looking for an opener, in the same pass rather than a
+ * prior one: a comment that merely mentions a quote (`# a docstring starts with """`)
+ * would otherwise open a span that runs to the next real delimiter, blanking every
+ * definition in between so its helpers vanish from every check that reads the
+ * structure. A `#` inside a literal is not a comment, which is why one pass has to
+ * decide both.
  */
-function blankPythonStrings(src) {
-    const out = src.split("");
-    const blank = (from, to) => {
-        for (let k = from; k < to; k++)
-            if (out[k] !== "\n")
-                out[k] = " ";
-    };
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        // A comment runs to the end of the line and holds no string opener.
-        if (c === "#") {
-            while (i < n && src[i] !== "\n")
+function pythonStringSpans(src) {
+    const out = [];
+    for (let i = 0; i < src.length; i++) {
+        const q = src[i];
+        if (q === "#") {
+            // Outside a literal by construction — a literal advances `i` past its end.
+            while (i < src.length && src[i] !== "\n")
                 i++;
             continue;
         }
-        if (c !== '"' && c !== "'") {
-            i++;
+        if (q !== '"' && q !== "'")
             continue;
-        }
-        // A string prefix (r, b, f, u, rb, …) is part of the literal, not of the quote.
-        const triple = src.startsWith(c.repeat(3), i);
-        const quote = triple ? c.repeat(3) : c;
-        const start = i;
-        i += quote.length;
-        let closed = false;
-        while (i < n) {
-            if (src[i] === "\\") {
-                i += 2;
+        const triple = src.startsWith(q + q + q, i);
+        const close = triple ? q + q + q : q;
+        let j = i + close.length;
+        let end = -1;
+        while (j < src.length) {
+            if (src[j] === "\\") {
+                j += 2;
                 continue;
             }
-            if (src.startsWith(quote, i)) {
-                i += quote.length;
-                closed = true;
+            if (src.startsWith(close, j)) {
+                end = j + close.length;
                 break;
             }
             // Only a triple-quoted literal may hold a raw newline.
-            if (src[i] === "\n" && !triple)
+            if (src[j] === "\n" && !triple)
                 break;
-            i++;
-        }
-        if (!closed) {
-            i = start + 1;
-            continue;
+            j++;
         }
-        blank(start + quote.length, i - quote.length);
+        if (end === -1)
+            continue; // never closed: not a literal
+        out.push({ start: i, end });
+        i = end - 1;
+    }
+    return out;
+}
+/** Comments and string CONTENTS blanked (quotes kept, line count preserved). Python
+ *  comments are `#…`; TS/JS go through the shared stripper. */
+/** String CONTENTS blanked (quotes kept, comments kept, line count preserved). */
+export function blankStrings(src, spec) {
+    if (spec.language !== "python")
+        return stripStrings(src);
+    return blankPythonStrings(src);
+}
+/**
+ * String CONTENTS blanked in Python source, quotes kept, offsets and line count
+ * preserved.
+ *
+ * Reads its literals from `pythonStringSpans` — the same scan `stringSpansOf` serves —
+ * so ONE definition decides what a Python literal is, for the callers that blank a
+ * literal and the callers that must copy one through unchanged.
+ *
+ * A line-by-line regex cannot do this. A `"""…"""` block spans lines, so a `#` inside a
+ * docstring or an embedded SQL block read as a comment, and every scanner built on this
+ * then treated quoted text as code the file executes — the delivery-time marker strip
+ * deleted a line out of a value rather than out of a comment, and a `def` at column 0
+ * inside a docstring ended a helper early and reappeared as a second definition of the
+ * same name.
+ */
+function blankPythonStrings(src) {
+    const out = src.split("");
+    for (const { start, end } of pythonStringSpans(src)) {
+        // The quote delimiters stay: callers read this copy for offsets and expect a
+        // literal to still look like one.
+        const q = src.startsWith(src[start].repeat(3), start) ? 3 : 1;
+        for (let i = start + q; i < end - q; i++)
+            out[i] = src[i] === "\n" ? "\n" : " ";
     }
     return out.join("");
 }
@@ -508,6 +540,47 @@ function signatureLines(body) {
     }
     return out;
 }
+/** The index of the first line of the decorator stack above `start`, or `start` when
+ *  there is none. Comments and blank lines may sit between decorators; anything else
+ *  ends the stack.
+ *
+ *  A decorator may span lines — `@retry(` … `)` — so the walk goes up by EXPRESSION,
+ *  not by line: from a line that closes more brackets than it opens, it keeps going
+ *  until the brackets balance, and only then asks whether that line starts with `@`.
+ *  A line-at-a-time walk sees `)` above the definition, stops there, and drops the
+ *  whole decorator out of the comparison.
+ *
+ *  Brackets are counted on `structure`, the copy with comments and string contents
+ *  blanked, for the same reason every other structural read here uses it: a bracket
+ *  typed inside a string (`retry_if_message(")")`) is not a bracket. The `@` itself is
+ *  read from `lines`, where it is still legible. Both copies keep the same line count,
+ *  so one index walks both.
+ *
+ *  Language-neutral: a definition with no `@` line simply gets `start` back. */
+function decoratorStart(lines, structure, start) {
+    let first = start;
+    let depth = 0;
+    for (let i = start - 1; i >= 0; i--) {
+        const l = lines[i].trim();
+        // Blank, or a comment: `structure` has comments blanked already, so the test
+        // is one and the same in every language — no prefix list to keep in step.
+        if (depth === 0 && (structure[i] ?? "").trim() === "")
+            continue;
+        for (const ch of structure[i] ?? "") {
+            if (")]}".includes(ch))
+                depth++;
+            else if ("([{".includes(ch))
+                depth--;
+        }
+        if (depth > 0)
+            continue; // inside a wrapped expression; keep walking up
+        depth = 0;
+        if (!l.startsWith("@"))
+            break;
+        first = i;
+    }
+    return first;
+}
 /** Whether the def at `start` carries `@overload` / `@typing.overload` anywhere in
  *  its decorator stack (comments and other decorators may sit between). */
 function isOverloadStub(lines, start) {

package/build/utils/utils-verify/retrofit-equivalence.d.ts

@@ -41,8 +41,3 @@ export interface RetrofitMismatch {
  * than a refusal the agent cannot act on.
  */
 export declare function retrofitMismatches(retrofitFile: string, utilsFiles: string[], spec: UtilsLanguageSpec): Promise<RetrofitMismatch[]>;
-/** The file's content at HEAD, or undefined when there is nothing to compare against
- *  (untracked, no git root, or git unavailable). Never throws. The ONE reader of a
- *  file's committed baseline on the utils path: the incumbent-signature gate reads
- *  the utils module through it too. */
-export declare function committedBaseline(file: string): Promise<string | undefined>;

package/build/utils/utils-verify/retrofit-equivalence.js

@@ -1,14 +1,9 @@
-import { execFile } from "child_process";
 import * as fs from "fs";
-import * as path from "path";
-import { promisify } from "util";
-import { logger } from "../logger.js";
-import { detectGitRoot } from "../gitStaging.js";
+import { contentAtHead } from "./head.js";
 import { blankCommentsAndStrings, parseUtilsFile } from "./parse.js";
 import { normalizePath } from "./language-spec.js";
 import { callText, hasSchemaCheck, requestFields, REQUEST_CALL_RE, SCHEMA_SCAN_LINES, shapeKeys, } from "./call-sites.js";
 import { escapeRegExp } from "../regex.js";
-const exec = promisify(execFile);
 /**
  * Whether a retrofit changed the request the rewired test sends.
  *
@@ -41,7 +36,7 @@ const exec = promisify(execFile);
  * than a refusal the agent cannot act on.
  */
 export async function retrofitMismatches(retrofitFile, utilsFiles, spec) {
-    const baseline = await committedBaseline(retrofitFile);
+    const baseline = await contentAtHead(retrofitFile);
     if (baseline === undefined)
         return [];
     let delivered;
@@ -191,30 +186,3 @@ function sameSet(a, b) {
             return false;
     return true;
 }
-/** The file's content at HEAD, or undefined when there is nothing to compare against
- *  (untracked, no git root, or git unavailable). Never throws. The ONE reader of a
- *  file's committed baseline on the utils path: the incumbent-signature gate reads
- *  the utils module through it too. */
-export async function committedBaseline(file) {
-    const root = detectGitRoot(file);
-    if (!root)
-        return undefined;
-    const rel = path.relative(root, file);
-    if (!rel || rel.startsWith(".."))
-        return undefined;
-    try {
-        const { stdout } = await exec("git", ["show", `HEAD:${rel}`], {
-            cwd: root,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        return stdout;
-    }
-    catch (err) {
-        // A file added by this run has no HEAD version — the common case, not an error.
-        logger.debug("No committed baseline for a retrofit; skipping equivalence", {
-            file,
-            error: String(err),
-        });
-        return undefined;
-    }
-}

package/build/utils/utils-verify/stage.js

@@ -1,15 +1,13 @@
-import { execFile } from "child_process";
-import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
 import { detectGitRoot, stageGeneratedPaths } from "../gitStaging.js";
 import { logger } from "../logger.js";
 import { isTestbotEnabled } from "../featureFlags.js";
 import { locateUtilsFiles, realpath } from "./locate.js";
+import { changedSinceHead } from "./head.js";
 import { locateInHouseModules } from "./in-house.js";
 import { CODEGEN_MARKER_RE } from "./call-sites.js";
 import { utilsSpecFor, utilsSpecForFile } from "./language-spec.js";
-const execFileAsync = promisify(execFile);
 export async function stageUtilsArtifacts(testFile, language) {
     const staged = [];
     const failed = [];
@@ -99,10 +97,7 @@ async function modifiedInHouseModules(testFile, language) {
         const modules = await locateInHouseModules({ testFile, spec, cwd: root });
         if (modules.length === 0)
             return [];
-        const { stdout } = await execFileAsync("git", ["diff", "-z", "--name-only", "--diff-filter=M", "HEAD"], { cwd: root, encoding: "utf8" });
-        const modified = new Set();
-        for (const rel of stdout.split("\0").filter(Boolean))
-            modified.add(await realpath(path.resolve(root, rel)));
+        const modified = new Set(await changedSinceHead(root, { filter: "M" }));
         return modules.map((m) => m.file).filter((f) => modified.has(f));
     }
     catch (err) {
@@ -117,18 +112,12 @@ async function modifiedSiblingsImporting(testFile, utilsFiles, language) {
         return [];
     let modified;
     try {
-        // `-z`: unquoted, NUL-separated — git C-quotes non-ASCII paths otherwise.
-        const { stdout } = await execFileAsync("git", 
         // Against HEAD, modified only: a test THIS run created is staged at discovery, so
         // its later STEP 5b edits show in a plain `git diff` and it would masquerade as a
         // pre-existing sibling (observed: the report gate then demanded an execution no
         // record could satisfy, and the agent un-shared the helpers to escape). Files
         // added since HEAD are excluded; they are staged by their own tool calls.
-        ["diff", "-z", "--name-only", "--diff-filter=M", "HEAD"], {
-            cwd: root,
-            encoding: "utf8",
-        });
-        modified = stdout.split("\0").filter(Boolean);
+        modified = await changedSinceHead(root, { filter: "M" });
     }
     catch (err) {
         logger.warning("Could not list modified files — edited sibling tests will not be staged", {
@@ -140,8 +129,7 @@ async function modifiedSiblingsImporting(testFile, utilsFiles, language) {
     const stems = utilsFiles.map((f) => path.basename(f).replace(/\.[^.]+$/, ""));
     const self = await realpath(testFile);
     const out = [];
-    for (const rel of modified) {
-        const abs = await realpath(path.resolve(root, rel));
+    for (const abs of modified) {
         if (abs === self || utilsFiles.includes(abs))
             continue;
         if (!spec.extensions.some((e) => abs.toLowerCase().endsWith(e)))

package/build/utils/utils-verify/verify.d.ts

@@ -1,7 +1,7 @@
 import { type UtilsTypecheck } from "./typecheck.js";
 import { type InlineCallSite, type UnextractedDuplicate } from "./call-sites.js";
 import { type UtilsAdvisoryKind, type UtilsViolationKind } from "./allow.js";
-import { type SingleImporterHelper } from "./importers.js";
+import { type HelperImporters } from "./importers.js";
 import { type HelperFamilySpec, type UtilsLanguageSpec } from "./language-spec.js";
 export interface UtilsViolation {
     kind: UtilsViolationKind;
@@ -60,8 +60,14 @@ export interface UtilsVerifyResult {
      *  findUnextractedDuplicates. API family only. */
     unextractedDuplicates: UnextractedDuplicate[];
     /** Helpers imported by 0 or 1 delivered test (SKYR-4276 A6). Advisory: a first run
-     *  seeds every helper single-use by design; the count is the trend to watch. */
-    singleImporters: SingleImporterHelper[];
+     *  seeds every helper single-use by design; the count is the trend to watch. Empty
+     *  whenever `importersComplete` is false — see there. */
+    singleImporters: HelperImporters[];
+    /** The importer walk read the whole directory. When false, `singleImporters` is
+     *  empty because the walk could not support a finding, NOT because every helper has
+     *  importers: a file it could not read may be the one importer of a helper. A
+     *  caller that states "nothing imports this" must consult it. */
+    importersComplete: boolean;
     /** The numbers the baseline assertion check compared — present only when a
      *  baseline was supplied and the spec was readable. The check is a COUNT: it
      *  cannot see one assertion swapped for another. The caller's text says so.

package/build/utils/utils-verify/verify.js

@@ -7,19 +7,20 @@ import { typecheckDelivered } from "./typecheck.js";
 import { blankComments, blankCommentsAndStrings, countAssertions, hasPageErrorGuard, parseUtilsFile, } from "./parse.js";
 import { escapeRegExp } from "../regex.js";
 import { detectGitRoot } from "../gitStaging.js";
-import { inlineCallSiteFamily, isModularizeFirstTarget, } from "../reuseRouting.js";
+import { inlineCallSiteFamily, isModularizeFirstTarget, isPomFirstTarget, } from "../reuseRouting.js";
 import { describeActionKey } from "./action-key.js";
 import { findDuplicateBodyReach, findUnreachableBodies } from "./body-reach.js";
 import { misnamedNewModules } from "./module-name.js";
+import { pageObjectCandidates } from "../pom-scope/ownership.js";
 import { additiveChanges, locateInHouseModules, resolveInHouseCalls, } from "./in-house.js";
 import { findSiblingInlineActionSites } from "./action-sites.js";
 import { findSiblingInlineCallSites, findUnextractedDuplicates, generatedSiblings, } from "./call-sites.js";
 import { parseUtilsAllows, } from "./allow.js";
 import { describeFixedSleeps, fixedSleepReplacement } from "./fixed-sleep.js";
-import { singleImporterHelpers, } from "./importers.js";
+import { singleImporterHelpers } from "./importers.js";
 import { assertsStatusEquality, defaultedStatusParam, pinnedStatusLiteral, restatedStatusAssertions, } from "./status-once.js";
 import { STATUS_ONCE_RULE } from "../../prompts/shared-helper-policy.js";
-import { committedBaseline } from "./retrofit-equivalence.js";
+import { contentAtHead } from "./head.js";
 import { incumbentSignatureViolations } from "./incumbent.js";
 import { helperFamilyFor, helperFamilyOf, scenarioNameViolation, utilsSpecFor, utilsSpecForFile, } from "./language-spec.js";
 /** What the compiler says about a name defined twice, which `helper-redefined`
@@ -80,9 +81,16 @@ export async function verifyUtils(params) {
     // locateInHouseModules). Found BEFORE the utils files so a customer module that
     // gained our header this run is judged by the additive gate, never by the Skyramp
     // invariants: the header locator would otherwise claim it.
-    const inHouse = spec
+    const located = spec
         ? await locateInHouseModules({ testFile: params.testFile, spec, cwd: root })
         : [];
+    // Both reuse settings on: a module that declares a class is a page object, which
+    // the page-object pass owned and its verifier checked. The in-house parser cannot
+    // read a class, and its additive gate would judge a page-object edit it did not
+    // prescribe — so the split is by shape, the one pom-scope/ownership.ts states.
+    const pomFirst = !!spec && isPomFirstTarget(spec.language, params.testType);
+    const pageObjectFiles = new Set(pomFirst ? (await pageObjectCandidates(located)).map((m) => m.file) : []);
+    const inHouse = located.filter((m) => !pageObjectFiles.has(m.file));
     const inHouseFiles = new Set(inHouse.map((m) => m.file));
     const utilsFiles = spec
         ? (await locateUtilsFiles({
@@ -107,6 +115,7 @@ export async function verifyUtils(params) {
         inlineCallSites: [],
         unextractedDuplicates: [],
         singleImporters: [],
+        importersComplete: false,
     };
     if (!spec)
         return result;
@@ -161,7 +170,7 @@ export async function verifyUtils(params) {
         // helpers this run writes, so a defaulted status on an incumbent is not advised
         // — and an incumbent's signature is held to what it was (incumbent.ts). Absent
         // for a module this run created, or outside git: then every helper is this run's.
-        const baseline = await committedBaseline(file);
+        const baseline = await contentAtHead(file);
         const headHelpers = baseline === undefined ? [] : parseUtilsFile(baseline, fileSpec);
         const incumbents = new Set(headHelpers.map((h) => h.name));
         incumbentsOfFile.set(file, incumbents);
@@ -321,6 +330,9 @@ export async function verifyUtils(params) {
         }
         if (utilsSet.has(imp.resolved) || imp.resolved === realTestFile)
             continue;
+        // The page-object pass's module: checked by its verifier, not this one.
+        if (pageObjectFiles.has(imp.resolved))
+            continue;
         if (inHouseFiles.has(imp.resolved)) {
             if (!inHouseResult)
                 unchecked.push(imp.resolved);
@@ -372,7 +384,7 @@ export async function verifyUtils(params) {
         if (!inHouseResult && inHouse.length > 0)
             result.inHouseChecksSkipped = `this pass ran ${params.testType
                 ? `as a ${params.testType.toLowerCase()} test`
-                : "with no test type supplied"}, and they run for a UI test with page-object reuse off`;
+                : "with no test type supplied"}, and they run for a UI test in TypeScript or JavaScript with utils reuse on`;
     }
     // The spec asserts a status a helper it calls already asserted on the response it
     // returned. Spec-level, like assertion-loss: the finding names the spec and the
@@ -478,12 +490,13 @@ export async function verifyUtils(params) {
             });
     }
     // One directory walk feeds every sibling advisory: each sibling is read exactly once.
-    let siblings = [];
+    let siblings = { files: [], complete: false };
     try {
         siblings = await generatedSiblings(params.testFile, spec, {
             includeSelf: true,
         });
         result.singleImporters = await singleImporterHelpers(params.testFile, utilsFiles, helpersByFile, spec, siblings);
+        result.importersComplete = siblings.complete;
     }
     catch {
         /* advisory only — never fails a verify */
@@ -864,9 +877,9 @@ incumbents = new Set()) {
             });
         }
         else if (sameName &&
-            h.arity !== undefined &&
-            sameName.arity !== undefined &&
-            h.arity !== sameName.arity &&
+            h.params !== undefined &&
+            sameName.params !== undefined &&
+            h.params.length !== sameName.params.length &&
             !(routeDuplicateOf?.file === sameName.file &&
                 routeDuplicateOf?.line === sameName.line)) {
             nameReported = true;
@@ -875,7 +888,7 @@ incumbents = new Set()) {
                 file,
                 helper: h.name,
                 line: h.line,
-                detail: `${h.name} is defined in two modules with different parameter lists — ${h.arity} parameter${h.arity === 1 ? "" : "s"} here, ${sameName.arity} at ${path.basename(sameName.file)}:${sameName.line}; the two modules disagree on one operation's signature, and the next test to import it gets whichever it finds first. Keep ONE definition, give every parameter the other lacked a default, and point every importer at it`,
+                detail: `${h.name} is defined in two modules with different parameter lists — ${h.params.length} parameter${h.params.length === 1 ? "" : "s"} here, ${sameName.params.length} at ${path.basename(sameName.file)}:${sameName.line}; the two modules disagree on one operation's signature, and the next test to import it gets whichever it finds first. Keep ONE definition, give every parameter the other lacked a default, and point every importer at it`,
             });
         }
         if (!inFile)
@@ -898,7 +911,8 @@ incumbents = new Set()) {
                     line: h.line,
                     // Only the parameter COUNT is compared, and only when both were read.
                     detail: first.name === h.name
-                        ? `${h.name} is defined twice (also at ${path.basename(first.file)}:${first.line}) with the same ${h.arity !== undefined && h.arity === first.arity
+                        ? `${h.name} is defined twice (also at ${path.basename(first.file)}:${first.line}) with the same ${h.params !== undefined &&
+                            h.params.length === first.params?.length
                             ? "parameter count and the same "
                             : ""}action sequence: ${describeActionKey(h.actionKey)}; keep one definition and point every importer at it`
                         : `${h.name} and ${first.name} (${path.basename(first.file)}:${first.line}) perform the same action sequence: ${describeActionKey(h.actionKey)}`,

package/node_modules/playwright/lib/dom-analyzer/blueprint.js

@@ -608,6 +608,7 @@ async function domEvaluationScript(options) {
     if (m && /[0-9]/.test(m[1])) return true;
     if (/[a-zA-Z][0-9]{3,}$/.test(id)) return true;
     if (id.includes(":")) return true;
+    if (/«r[0-9a-z]*»|(^|[-_])_?r_[0-9a-z]+_/.test(id)) return true;
     if (/^.+__search_[a-zA-Z0-9]{4,}$/.test(id)) return true;
     return false;
   }

package/node_modules/playwright/lib/dom-analyzer/dynamicId.js

@@ -34,6 +34,7 @@ function isDynamicId(id) {
   if (shortHexMatch && /[0-9]/.test(shortHexMatch[1])) return true;
   if (/[a-zA-Z][0-9]{3,}$/.test(id)) return true;
   if (id.includes(":")) return true;
+  if (/«r[0-9a-z]*»|(^|[-_])_?r_[0-9a-z]+_/.test(id)) return true;
   if (/^.+__search_[a-zA-Z0-9]{4,}$/.test(id)) return true;
   return false;
 }

package/node_modules/playwright/lib/dom-analyzer/dynamicId.test.js

@@ -65,6 +65,12 @@ test("isDynamicId: single trailing digit after letter is not dynamic", () => {
   assertFalse((0, import_dynamicId.isDynamicId)("item1"), "item1 (single digit)");
   assertFalse((0, import_dynamicId.isDynamicId)("item12"), "item12 (2 digits, below 3-digit threshold)");
 });
+test("isDynamicId: React 19 useId forms", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("\xABr2\xBB-form-item"), "\xABr2\xBB-form-item (React 19.0)");
+  assertTrue((0, import_dynamicId.isDynamicId)("radix-_r_16_"), "radix-_r_16_ (React 19.1 inside Radix)");
+  assertTrue((0, import_dynamicId.isDynamicId)("_r_1k_"), "_r_1k_ (bare React 19.1)");
+  assertFalse((0, import_dynamicId.isDynamicId)("user_r_name"), "user_r_name (word, not a useId)");
+});
 let failed = 0;
 for (const { name, run } of cases) {
   try {