@skyramp/mcp 0.4.2 → 0.4.3-rc.2

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

@@ -7,19 +7,21 @@ 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 { addedSinceHead, changedSinceHead, contentAtHead, readAtHead, } from "./head.js";
+import { alignLines, BaselineErrors, baselineErrorKey, inheritedTypeError, } from "./changed-lines.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`
@@ -51,9 +53,11 @@ const REDECLARATION_CODES = new Set([2393, 2323, 2451]);
  *    returned. See status-once.ts.
  *  - `type-error` (TypeScript): the delivered module or spec fails the compiler with
  *    every strictness flag off — an error under every configuration (a path parameter
- *    typed `unknown`, request options built as a record and handed to `sendRequest`).
- *    An error only the repository's own tsconfig raises is the `tsconfig-type-error`
- *    ADVISORY. See typecheckDelivered.
+ *    typed `unknown`, request options built as a record and handed to `sendRequest`)
+ *    — and this run CAUSED it: an error the file already had at HEAD on an
+ *    unchanged line is the `inherited-type-error` ADVISORY, and an error only the
+ *    repository's own tsconfig raises is the `tsconfig-type-error` ADVISORY. See
+ *    typecheckDelivered and inheritedTypeError.
  *
  * Analyses the utils files' INTERNAL invariants — unlike the POM verifier, which
  * checks a spec's cross-file references — so it reads the utils files, not the spec,
@@ -80,9 +84,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({
@@ -94,6 +105,8 @@ export async function verifyUtils(params) {
     const result = {
         ok: true,
         utilsFiles,
+        incumbentModules: [],
+        headUnknownModules: [],
         helpers: 0,
         imported: 0,
         importedNames: [],
@@ -107,6 +120,7 @@ export async function verifyUtils(params) {
         inlineCallSites: [],
         unextractedDuplicates: [],
         singleImporters: [],
+        importersComplete: false,
     };
     if (!spec)
         return result;
@@ -127,6 +141,11 @@ export async function verifyUtils(params) {
      *  kept: both the status advisory's scope and the restatement's remediation
      *  turn on it. */
     const incumbentsOfFile = new Map();
+    /** Per utils file, the module at HEAD — `undefined` for a module HEAD does not
+     *  hold. The compiler's attribution reads it: an error the module already had at
+     *  HEAD is not this run's. */
+    const headContentOfFile = new Map();
+    const contentOfFile = new Map();
     const allHelpers = [];
     const helpersByFile = new Map();
     const allAllows = [];
@@ -161,10 +180,17 @@ 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 atHead = await readAtHead(file);
+        const baseline = "content" in atHead ? atHead.content : undefined;
+        if (baseline !== undefined)
+            result.incumbentModules.push(file);
+        else if ("unknown" in atHead)
+            result.headUnknownModules.push(file);
         const headHelpers = baseline === undefined ? [] : parseUtilsFile(baseline, fileSpec);
         const incumbents = new Set(headHelpers.map((h) => h.name));
         incumbentsOfFile.set(file, incumbents);
+        headContentOfFile.set(file, baseline);
+        contentOfFile.set(file, content);
         pending.push(...incumbentSignatureViolations(headHelpers, helpers, file));
         for (const h of helpers) {
             // A static reading of the signature. An unannotated parameter is an error only
@@ -321,6 +347,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 +401,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
@@ -419,8 +448,10 @@ export async function verifyUtils(params) {
     // The compiler over the delivered files: the shared module(s) and the spec that
     // imports them. The executor transpiles TypeScript without typechecking it, so
     // this is the first typecheck the files meet before the customer's own. An error
-    // under the permissive settings fails under every configuration and blocks; one
-    // only the repository's tsconfig raises advises (see typecheckDelivered).
+    // under the permissive settings fails under every configuration and blocks when
+    // this run caused it — one the file already had at HEAD advises (see the
+    // attribution below); one only the repository's tsconfig raises advises (see
+    // typecheckDelivered).
     // Over the TypeScript files only, by extension: a JavaScript module is not
     // typechecked (its spec would be `checkJs`, which no delivered file relies on),
     // and a JavaScript spec is not compiled beside a TypeScript module.
@@ -432,7 +463,7 @@ export async function verifyUtils(params) {
         const realSpec = await realpath(params.testFile);
         const specFile = realSpec && isTs(realSpec) ? realSpec : undefined;
         const files = specFile ? [...tsUtils, specFile] : tsUtils;
-        const tc = await typecheckDelivered(files);
+        const tc = await typecheckDelivered(files, { anchor: specFile });
         result.typecheck = tc;
         const subjectOf = (file, line) => file === specFile
             ? path.basename(specFile).replace(/\W/g, "_")
@@ -447,11 +478,96 @@ export async function verifyUtils(params) {
         const redefined = new Set(pending
             .filter((v) => v.kind === "helper-redefined")
             .map((v) => `${v.file}\0${v.helper}`));
+        // The files as the repository held them BEFORE this run — each at HEAD —
+        // compiled once more, so that an error is excused only when the repository
+        // already had it on the same line: attribution by CAUSE. A file HEAD does not
+        // hold (a module or a spec this run created) is hidden from that compile and
+        // every error in it is this run's — the generator's included: a line any
+        // pass of this run wrote is the run's to fix, and only what the customer or
+        // an earlier run committed is not.
+        const baselineContents = new Map();
+        const hidden = new Set();
+        const attribution = {
+            ran: false,
+            headUnknown: [...result.headUnknownModules],
+        };
+        result.attribution = attribution;
+        for (const file of tsUtils) {
+            const head = headContentOfFile.get(file);
+            if (head === undefined)
+                hidden.add(file);
+            else
+                baselineContents.set(file, head);
+        }
+        if (specFile) {
+            const specAtHead = await readAtHead(specFile);
+            if ("content" in specAtHead)
+                baselineContents.set(specFile, specAtHead.content);
+            else {
+                hidden.add(specFile);
+                if ("unknown" in specAtHead)
+                    attribution.headUnknown.push(specFile);
+            }
+        }
+        // Every OTHER file the program may reach — a page object, an in-house helper,
+        // a config module — as HEAD held it too: one the run changed is served from
+        // HEAD, one the run added does not exist. Read from the working tree, a
+        // page-object edit put its error into both compiles and it was excused as
+        // inherited. Only the extensions the compiler reads; nothing under
+        // node_modules, which the run does not edit.
+        // Nothing to attribute on a clean compile: the HEAD compile — a full second
+        // program build — is skipped, and the skip is stated so the field is never
+        // read as "attribution ran and excused nothing".
+        const baselineErrors = new BaselineErrors();
+        if (tc.errors.length === 0)
+            attribution.reason = "the delivered files compiled clean";
+        else if (baselineContents.size === 0)
+            attribution.reason =
+                "no delivered file exists at HEAD, so there is nothing to inherit from";
+        else if (!(await addBaselineForChangedFiles(root, baselineContents, hidden)))
+            attribution.reason =
+                "the files this run changed could not be listed, so no file could be read at HEAD";
+        else {
+            const before = await typecheckDelivered([...baselineContents.keys()], {
+                anchor: specFile,
+                baseline: { contents: baselineContents, hidden },
+            });
+            if (!before.ran) {
+                // The delivered compile ran and this one did not: something in the HEAD
+                // content or the host. Stated, never silent — the old errors then block
+                // as this run's, which is the outcome attribution exists to prevent.
+                attribution.reason = `the HEAD compile did not run: ${before.reason ?? "unknown cause"}`;
+                logger.warning("The HEAD compile did not run — no type error will be excused as inherited", { testFile: params.testFile, reason: before.reason });
+            }
+            else {
+                attribution.ran = true;
+                for (const e of before.errors)
+                    baselineErrors.add(baselineErrorKey(e.file, e.line, e.code, e.message));
+            }
+        }
+        const unchangedOf = new Map();
+        for (const [file, before] of baselineContents) {
+            const now = file === specFile ? specContent : contentOfFile.get(file);
+            if (now !== undefined)
+                unchangedOf.set(file, alignLines(before, now));
+        }
+        const inherited = inheritedTypeError((file) => unchangedOf.get(file), baselineErrors);
         for (const e of tc.errors) {
             const helper = subjectOf(e.file, e.line);
             if (REDECLARATION_CODES.has(e.code) &&
                 redefined.has(`${e.file}\0${helper}`))
                 continue;
+            const why = inherited(e.file, e.line, e.code, e.message);
+            if (why !== undefined) {
+                result.advisories.push({
+                    kind: "inherited-type-error",
+                    file: e.file,
+                    helper,
+                    line: e.line,
+                    detail: `\`TS${e.code}: ${e.message}\` — ${why}`,
+                });
+                continue;
+            }
             pending.push({
                 kind: "type-error",
                 file: e.file,
@@ -478,12 +594,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 */
@@ -673,6 +790,50 @@ function remediation(helper, literal, incumbent) {
 }
 /** The compared counts as one phrase, shared by the assertion-loss detail and the
  *  PASSED line's note so the two cannot drift. */
+/** Extensions the compiler reads as source. */
+const COMPILED_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+]);
+/**
+ * Add to the baseline every compiled file in the repository that differs from
+ * HEAD and is not already accounted for: changed files served from HEAD, added
+ * files hidden. Returns whether the listing succeeded — a baseline that cannot
+ * be completed must excuse NOTHING, since any file it reads from disk may carry
+ * the run's own edit; the caller then compiles no baseline and every error
+ * blocks, as before attribution existed.
+ */
+async function addBaselineForChangedFiles(root, contents, hidden) {
+    if (!root)
+        return true; // outside git nothing has a HEAD; nothing is excused
+    const compiled = (f) => COMPILED_EXTENSIONS.has(path.extname(f)) &&
+        !f.split(path.sep).includes("node_modules");
+    try {
+        for (const file of await changedSinceHead(root, { filter: "M" })) {
+            if (!compiled(file) || contents.has(file) || hidden.has(file))
+                continue;
+            const head = await contentAtHead(file, root);
+            if (head === undefined)
+                return false; // git did not answer: excuse nothing
+            contents.set(file, head);
+        }
+        for (const file of await addedSinceHead(root))
+            if (compiled(file) && !contents.has(file))
+                hidden.add(file);
+        return true;
+    }
+    catch (err) {
+        logger.warning("Could not list the files this run changed — no type error will be excused as inherited", { root, error: String(err) });
+        return false;
+    }
+}
 export function describeAssertionCount(c) {
     return `${c.baseline} assertions at the modularization hand-out, ${c.delivered} delivered (${c.inSpec} in the test, ${c.inHelpers} in the helpers it imports and calls)`;
 }
@@ -864,9 +1025,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 +1036,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 +1059,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/build/utils/versions.d.ts

@@ -1,4 +1,4 @@
-export declare const SKYRAMP_IMAGE_VERSION = "v1.3.46";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.46";
-export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.46";
+export declare const SKYRAMP_IMAGE_VERSION = "v1.3.47";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.47";
+export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.47";
 export declare const WORKER_CONTROL_PORT = 35142;

package/build/utils/versions.js

@@ -1,4 +1,4 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.46";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.47";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;
 // Control port the Skyramp worker listens on (SDK `CONTAINER_PORT`).

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 {

package/node_modules/playwright/lib/mcp/skyramp/exportTool.js

@@ -88,10 +88,12 @@ Requested path: ${outputZip}` }],
         counter++;
       outputZip = `${base}_${counter}${ext}`;
     }
-    const { jsonl: jsonlContent, actionCount, skipped } = (0, import_skyRampExport.buildJsonlContent)(ctx.trackedActions, "chromium", ctx.harPath);
+    const { jsonl: jsonlContent, actionCount, skipped, simplified } = (0, import_skyRampExport.buildJsonlContent)(ctx.trackedActions, "chromium", ctx.harPath);
     await (0, import_skyRampExport.writeSkyrampZip)(outputZip, jsonlContent, ctx.harPath);
     const skippedNote = skipped.length ? `
 Skipped (not exportable): ${[...new Set(skipped)].join(", ")}` : "";
+    const simplifiedNote = simplified.length ? `
+Exported with a simplified locator (a part the trace format cannot carry was dropped, so the step may match more elements at replay): ${[...new Set(simplified)].join("; ")}` : "";
     const dropped = ctx.droppedActions ?? [];
     const droppedNote = dropped.length ? `
 Failed & dropped (not recorded): ${summarizeDropped(dropped)}` : "";
@@ -102,7 +104,7 @@ Failed & dropped (not recorded): ${summarizeDropped(dropped)}` : "";
 Skyramp zip written to ${outputZip}
 
 Contains:
-- skyramp_playwright.txt (${actionCount} actions)${skippedNote}${droppedNote}`
+- skyramp_playwright.txt (${actionCount} actions)${skippedNote}${simplifiedNote}${droppedNote}`
       }]
     };
   };

package/node_modules/playwright/lib/mcp/skyramp/snapshotLocators.js

@@ -0,0 +1,246 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var snapshotLocators_exports = {};
+__export(snapshotLocators_exports, {
+  exactLeaf: () => exactLeaf,
+  isInputLine: () => isInputLine,
+  isTestHookCss: () => isTestHookCss,
+  isVolatileCss: () => isVolatileCss,
+  leaf: () => leaf,
+  locatorFromSelector: () => locatorFromSelector,
+  renderSelector: () => renderSelector,
+  snapshotInputValue: () => snapshotInputValue,
+  snapshotLineText: () => snapshotLineText,
+  snapshotMatches: () => snapshotMatches,
+  unquoteYaml: () => unquoteYaml,
+  withNth: () => withNth
+});
+module.exports = __toCommonJS(snapshotLocators_exports);
+var import_dynamicId = require("../../dom-analyzer/dynamicId");
+const INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "searchbox", "combobox", "spinbutton"]);
+function isInputLine(refLine) {
+  const role = refLine.match(/^\s*-\s*(\w+)/)?.[1];
+  return !!role && INPUT_ROLES.has(role);
+}
+function snapshotInputValue(snapLines, refIdx) {
+  if (refIdx < 0)
+    return "";
+  const refLine = snapLines[refIdx];
+  const inline = refLine.match(/\]:\s*(.+)$/)?.[1]?.trim();
+  if (inline)
+    return unquoteYaml(inline);
+  if (!isInputLine(refLine))
+    return "";
+  const indentOf = (line) => line.match(/^(\s*)/)?.[1]?.length ?? 0;
+  const indent = indentOf(refLine);
+  let childIndent;
+  for (let i = refIdx + 1; i < snapLines.length; i++) {
+    const lineIndent = indentOf(snapLines[i]);
+    if (lineIndent <= indent)
+      break;
+    childIndent ??= lineIndent;
+    if (lineIndent !== childIndent)
+      continue;
+    const child = snapLines[i].match(/^\s*-\s*text:\s*(.+?)\s*$/)?.[1];
+    if (child !== void 0)
+      return unquoteYaml(child);
+  }
+  return "";
+}
+function snapshotLineText(line) {
+  const quoted = line.match(/^\s*-\s*\w+\s+"([^"]*)"/);
+  if (quoted)
+    return quoted[1];
+  const colon = line.match(/\[ref=\w+\](?:\s*\[[^\]]*\])*\s*:\s*(.+?)\s*$/);
+  const value = colon?.[1]?.trim();
+  return value ? unquoteYaml(value) : null;
+}
+function unquoteYaml(value) {
+  if (/^"(?:[^"\\]|\\.)*"$/.test(value)) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function snapshotMatches(snapLines, locator) {
+  if (locator.next)
+    return void 0;
+  const text = locator.kind === "text" ? locator.body : locator.kind === "role" ? locator.options?.name : void 0;
+  if (typeof text !== "string")
+    return void 0;
+  const exact = !!locator.options?.exact;
+  const same = (v) => v !== null && (exact ? v === text : v.toLowerCase().includes(text.toLowerCase()));
+  return snapLines.filter((l) => {
+    if (locator.kind === "role") {
+      const m = l.match(/^\s*-\s*(\w+)\s+"([^"]*)"/);
+      return !!m && m[1] === locator.body && same(m[2]);
+    }
+    return same(snapshotLineText(l));
+  }).length;
+}
+function isVolatileCss(selector) {
+  return selector.startsWith("#") && (0, import_dynamicId.isDynamicId)(selector.slice(1));
+}
+function isTestHookCss(selector) {
+  return /^(?:[a-z][\w-]*)?\[data-[\w-]+=(?:"[^"]+"|'[^']+')\]$/i.test(selector);
+}
+function renderSelector(locator) {
+  const q = (v, exact) => `${JSON.stringify(v)}${exact ? "s" : "i"}`;
+  let head;
+  switch (locator.kind) {
+    case "test-id":
+      head = `internal:testid=[${locator.options?.attribute ?? "data-testid"}=${JSON.stringify(locator.body)}s]`;
+      break;
+    case "role":
+      head = `internal:role=${locator.body}${typeof locator.options?.name === "string" ? `[name=${q(locator.options.name, locator.options.exact)}]` : ""}`;
+      break;
+    case "text":
+      head = `internal:text=${q(locator.body, locator.options?.exact)}`;
+      break;
+    case "label":
+      head = `internal:label=${q(locator.body, locator.options?.exact)}`;
+      break;
+    case "has-text":
+      head = `internal:has-text=${q(locator.body, locator.options?.exact)}`;
+      break;
+    case "placeholder":
+    case "alt":
+    case "title":
+      head = `internal:attr=[${locator.kind}=${q(locator.body, locator.options?.exact)}]`;
+      break;
+    case "nth":
+      head = `nth=${locator.body}`;
+      break;
+    default:
+      head = String(locator.body);
+      break;
+  }
+  return locator.next ? `${head} >> ${renderSelector(locator.next)}` : head;
+}
+function leaf(locator) {
+  let tail = locator;
+  while (tail.next)
+    tail = tail.next;
+  return tail;
+}
+const copyChain = (l) => ({ ...l, options: { ...l.options }, ...l.next ? { next: copyChain(l.next) } : {} });
+function exactLeaf(parsed, fullText) {
+  const locator = copyChain(parsed.locator);
+  const tail = leaf(locator);
+  const leafText = tail.kind === "text" ? tail.body : tail.kind === "role" ? tail.options?.name : void 0;
+  if (typeof leafText !== "string" || leafText !== fullText)
+    return parsed;
+  tail.options = { ...tail.options, exact: true };
+  return { selector: renderSelector(locator), locator };
+}
+function withNth(parsed, index) {
+  const locator = copyChain(parsed.locator);
+  leaf(locator).next = { kind: "nth", body: String(index), options: { attrs: [], exact: false } };
+  return { selector: renderSelector(locator), locator };
+}
+function selectorParts(selector) {
+  const parts = [];
+  let quote;
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < selector.length; i++) {
+    const c = selector[i];
+    if (quote) {
+      if (c === "\\")
+        i++;
+      else if (c === quote)
+        quote = void 0;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === "[" || c === "(") {
+      depth++;
+    } else if (c === "]" || c === ")") {
+      depth--;
+    } else if (!depth && selector.startsWith(" >> ", i)) {
+      parts.push(selector.slice(start, i));
+      start = i + 4;
+      i += 3;
+    }
+  }
+  parts.push(selector.slice(start));
+  return parts;
+}
+const QUOTED = '("(?:[^"\\\\]|\\\\.)*")([is])';
+function decodeQuoted(quoted) {
+  try {
+    return JSON.parse(quoted.replace(/[\u0000-\u001f]/g, (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0")));
+  } catch {
+    return void 0;
+  }
+}
+function locatorFromSelector(selector, opts = {}) {
+  const links = [];
+  for (const part of selectorParts(selector)) {
+    let m;
+    let value;
+    if (m = part.match(/^nth=(-?\d+)$/)) {
+      links.push({ kind: "nth", body: m[1], options: { attrs: [], exact: false } });
+    } else if (m = part.match(new RegExp(`^internal:role=([a-z]+)(?:\\[name=${QUOTED}\\])?$`))) {
+      if (m[2] && (value = decodeQuoted(m[2])) === void 0)
+        return null;
+      links.push({ kind: "role", body: m[1], options: { attrs: [], exact: m[3] === "s", ...m[2] ? { name: value } : {} } });
+    } else if (m = part.match(new RegExp(`^internal:testid=\\[([\\w-]+)=${QUOTED}\\]$`))) {
+      if ((value = decodeQuoted(m[2])) === void 0)
+        return null;
+      links.push({ kind: "test-id", body: value, options: m[1] === "data-testid" ? {} : { attribute: m[1] } });
+    } else if (m = part.match(new RegExp(`^internal:(label|text|has-text)=${QUOTED}$`))) {
+      if ((value = decodeQuoted(m[2])) === void 0)
+        return null;
+      links.push({ kind: m[1], body: value, options: { exact: m[3] === "s" } });
+    } else if (m = part.match(new RegExp(`^internal:attr=\\[(placeholder|alt|title)=${QUOTED}\\]$`))) {
+      if ((value = decodeQuoted(m[2])) === void 0)
+        return null;
+      links.push({ kind: m[1], body: value, options: { exact: m[3] === "s" } });
+    } else if (/^(?:[a-z-]+=|internal:|\/\/|\.\.)/i.test(part) || !part.trim()) {
+      return null;
+    } else {
+      links.push({ kind: "default", body: part, options: {} });
+    }
+  }
+  while (!opts.keepTrailingNth && links.length && links[links.length - 1].kind === "nth")
+    links.pop();
+  if (!links.length || links[0].kind === "nth")
+    return null;
+  for (let i = links.length - 1; i > 0; i--)
+    links[i - 1].next = links[i];
+  return links[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exactLeaf,
+  isInputLine,
+  isTestHookCss,
+  isVolatileCss,
+  leaf,
+  locatorFromSelector,
+  renderSelector,
+  snapshotInputValue,
+  snapshotLineText,
+  snapshotMatches,
+  unquoteYaml,
+  withNth
+});