@ivorycanvas/qamap 0.3.1 → 0.3.3

package/dist/e2e.js

@@ -1,12 +1,14 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import YAML from "yaml";
 import { buildDomainLanguageSummary } from "./domain-language.js";
 import { defaultDomainManifestPath, loadDomainManifest, matchDomains } from "./domains.js";
 import { collectProjectFiles } from "./fs.js";
+import { buildReverseImportIndex, expandChangedFilesWithImporters, findImportingSurfaces } from "./import-graph.js";
 import { loadCoreFlowManifest, matchCoreFlows } from "./flows.js";
 import { loadVerificationManifest, matchVerificationManifest } from "./manifest.js";
 import { collectTestSuiteInventory, evaluateFlowCoverageEvidence, summarizeTestSuiteInventory, } from "./test-evidence.js";
-import { generateTestPlan } from "./test-plan.js";
+import { collectAddedDiffText, generateTestPlan } from "./test-plan.js";
 import { TOOL_NAME, VERSION } from "./version.js";
 const maxFilesPerFlow = 8;
 const workspacePackageSearchLimit = 200;
@@ -34,14 +36,21 @@ export async function generateE2ePlan(rootInput, options = {}) {
     const coreFlowRoot = testPlan.workspaceRoot ?? root;
     const coreFlowManifest = await loadCoreFlowManifest(coreFlowRoot);
     const coreFlowChangedFiles = toCoreFlowChangedFiles(testPlan.changedFiles, root, coreFlowRoot);
-    const coreFlows = matchCoreFlows(coreFlowManifest, coreFlowChangedFiles);
+    const matchableChangedFiles = await expandChangedFilesForMatching(coreFlowRoot, coreFlowChangedFiles);
+    const coreFlows = matchCoreFlows(coreFlowManifest, matchableChangedFiles);
     const domainManifest = await loadDomainManifest(coreFlowRoot);
-    const domains = matchDomains(domainManifest, coreFlowChangedFiles);
+    const domains = matchDomains(domainManifest, matchableChangedFiles);
     const verificationManifest = await loadVerificationManifest(coreFlowRoot, { manifestPath: options.manifestPath });
-    const verificationManifestMatches = matchVerificationManifest(verificationManifest, coreFlowChangedFiles);
-    const domainLanguage = await buildDomainLanguageSummary(root, testPlan.changedFiles, coreFlows, domains);
+    const verificationManifestMatches = matchVerificationManifest(verificationManifest, matchableChangedFiles);
+    const addedDiffText = await collectAddedDiffText(root, {
+        base: testPlan.base,
+        head: testPlan.head,
+        workspaceRoot: testPlan.workspaceRoot,
+        includeWorkingTree: options.includeWorkingTree,
+    });
+    const domainLanguage = await buildDomainLanguageSummary(root, testPlan.changedFiles, coreFlows, domains, addedDiffText);
     const workspaceTargets = await buildWorkspaceTargets(root, testPlan);
-    const flows = await buildFlows(root, testPlan.changedFiles, recommendedRunner.name, project.type, testSuiteInventory, domainLanguage);
+    const flows = await buildFlows(root, testPlan.changedFiles, recommendedRunner.name, project.type, testSuiteInventory, domainLanguage, addedDiffText);
     const testSuite = summarizeTestSuiteInventory(testSuiteInventory);
     const missingTestability = uniqueStrings([
         ...flows.flatMap((flow) => flow.missingTestability),
@@ -105,6 +114,12 @@ export async function generateE2ePlan(rootInput, options = {}) {
 export async function generateE2eDraft(rootInput, options = {}) {
     const root = path.resolve(rootInput);
     const plan = await generateE2ePlan(root, options);
+    const addedDiffText = await collectAddedDiffText(root, {
+        base: plan.base,
+        head: plan.head,
+        workspaceRoot: plan.workspaceRoot,
+        includeWorkingTree: options.includeWorkingTree,
+    });
     const runner = plan.recommendedRunner.name;
     const outputDirectory = path.resolve(root, options.output ?? defaultDraftOutputDirectory(runner));
     const draftLimit = options.maxDrafts && options.maxDrafts > 0 ? Math.floor(options.maxDrafts) : undefined;
@@ -121,7 +136,7 @@ export async function generateE2eDraft(rootInput, options = {}) {
         const promotionGuidance = buildDraftPromotionGuidance(flow);
         const fileAlreadyExists = await exists(filePath);
         const shouldSkip = fileAlreadyExists && !options.force && !dryRun;
-        const content = shouldSkip ? ((await readTextIfExists(filePath)) ?? "") : draftContentForFlow(plan, flow, runner);
+        const content = shouldSkip ? ((await readTextIfExists(filePath)) ?? "") : draftContentForFlow(plan, flow, runner, addedDiffText);
         const todoCount = countTodos(content);
         const selfCheck = evaluateDraftSelfCheck(plan, flow, runner, content, todoCount);
         const actionItems = buildDraftActionItems(plan, flow, runner, validationSummary, promotionGuidance, selfCheck);
@@ -1214,7 +1229,7 @@ function inferFlowActor(flow) {
     if (/\b(auth|login|logout|session|account|profile|permission)\b/.test(haystack)) {
         return "Signed-in user or guest";
     }
-    if (/\b(checkout|purchase|payment|order|cart|offer|subscription|membership|billing)\b/.test(haystack)) {
+    if (/\b(checkout|purchase|payment|order|cart|offer|listing|subscription|membership|billing)\b/.test(haystack)) {
         return "Customer";
     }
     if (hasUserFacingEntrypointOrFile(flow)) {
@@ -1929,6 +1944,27 @@ export function formatMarkdownE2eSetup(result) {
     }
     return lines.join("\n");
 }
+const frameworkSignalDependencies = [
+    "expo",
+    "react-native",
+    "@playwright/test",
+    "playwright",
+    "@angular/core",
+    "@remix-run/react",
+    "astro",
+    "next",
+    "nuxt",
+    "react-dom",
+    "react-router-dom",
+    "svelte",
+    "vue",
+    "vite",
+    "@nestjs/core",
+    "express",
+    "fastify",
+    "koa",
+    "hono",
+];
 async function detectProjectProfile(root, workspaceRoot) {
     const profileRoots = profileSearchRoots(root, workspaceRoot);
     const packageJson = await readPackageJson(root);
@@ -1940,6 +1976,20 @@ async function detectProjectProfile(root, workspaceRoot) {
         ...(packageJson?.devDependencies ?? {}),
     };
     const evidence = [];
+    const rootHasFrameworkSignal = frameworkSignalDependencies.some((dependency) => dependency in dependencies);
+    if (!rootHasFrameworkSignal) {
+        const memberDependencies = await collectWorkspaceMemberDependencies(root, packageJson);
+        for (const member of memberDependencies) {
+            for (const [dependency, version] of Object.entries(member.dependencies)) {
+                if (!(dependency in dependencies)) {
+                    dependencies[dependency] = version;
+                }
+            }
+            if (member.frameworkSignals.length > 0) {
+                evidence.push(`workspace member ${member.directory}: ${member.frameworkSignals.join(", ")}`);
+            }
+        }
+    }
     const hasExpoDependency = "expo" in dependencies;
     const hasReactNativeDependency = "react-native" in dependencies;
     const hasPlaywrightDependency = "@playwright/test" in dependencies || "playwright" in dependencies;
@@ -2942,21 +2992,64 @@ function toCoreFlowChangedFiles(changedFiles, scopedRoot, coreFlowRoot) {
         previousPath: file.previousPath ? toPosixPath(path.join(relativeRoot, file.previousPath)) : undefined,
     }));
 }
-async function buildFlows(root, changedFiles, runner, projectType, testSuiteInventory, domainLanguage) {
+async function buildFlows(root, changedFiles, runner, projectType, testSuiteInventory, domainLanguage, addedDiffText = {}) {
     const files = changedFiles.map((file) => file.path);
+    const importImpacts = await collectImportImpacts(root, files);
     const fixtureContext = await collectFixtureReadinessContext(root, files);
-    const flowResults = await Promise.all(buildFlowCandidates(files, runner, projectType, domainLanguage).map((candidate) => buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext)));
+    const flowResults = await Promise.all(buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts).map((candidate) => buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext, addedDiffText)));
     const flows = flowResults.filter((flow) => Boolean(flow));
     return dedupeFlows(flows).slice(0, 4);
 }
-function buildFlowCandidates(files, runner, projectType, domainLanguage) {
-    const lowSignalCandidate = buildLowSignalChangeCandidate(files);
+async function expandChangedFilesForMatching(root, changedFiles) {
+    if (changedFiles.length === 0 || changedFiles.length > 60) {
+        return changedFiles;
+    }
+    try {
+        const expansion = await expandChangedFilesWithImporters(root, changedFiles.map((file) => file.path));
+        const knownPaths = new Set(changedFiles.map((file) => file.path));
+        const importerEntries = expansion.files
+            .filter((file) => !knownPaths.has(file))
+            .map((file) => ({ status: "M", path: file }));
+        return [...changedFiles, ...importerEntries];
+    }
+    catch {
+        return changedFiles;
+    }
+}
+function isRoutableSurfaceFile(file) {
+    if (isApiRouteFile(file) || isTestLikeFile(file)) {
+        return false;
+    }
+    return (/(?:^|\/)app\/.*(?:^|\/)?page\.[cm]?[jt]sx?$/i.test(file) ||
+        /(?:^|\/)pages\/(?!api\/).+\.(?:[cm]?[jt]sx?|vue|svelte)$/i.test(file) ||
+        /(?:^|\/)(?:screens|views)\/.+\.(?:[cm]?[jt]sx?|vue|svelte)$/i.test(file) ||
+        /(?:^|\/)routes\/(?!api\/).+\.(?:[cm]?[jt]sx?|vue|svelte)$/i.test(file));
+}
+async function collectImportImpacts(root, changedFiles) {
+    const propagatableFiles = changedFiles.filter((file) => !isRoutableSurfaceFile(file) && !isTestLikeFile(file) && !isConfigLikeFile(file) && !isContentOrStyleFile(file));
+    if (propagatableFiles.length === 0) {
+        return [];
+    }
+    try {
+        const index = await buildReverseImportIndex(root);
+        return findImportingSurfaces(index, propagatableFiles, isRoutableSurfaceFile);
+    }
+    catch {
+        return [];
+    }
+}
+function describeImportChain(impact) {
+    return impact.chain.join(" -> ");
+}
+function buildFlowCandidates(files, runner, projectType, domainLanguage, importImpacts = []) {
+    const lowSignalCandidate = importImpacts.length === 0 ? buildLowSignalChangeCandidate(files) : undefined;
     if (lowSignalCandidate) {
         return [lowSignalCandidate];
     }
     const behaviorFiles = files.filter((file) => !isTestLikeFile(file));
     const candidateFiles = behaviorFiles.length > 0 ? behaviorFiles : files;
-    const uiFiles = candidateFiles.filter(isUserFacingFile);
+    const impactSurfaceFiles = importImpacts.map((impact) => impact.surface).filter((surface) => !candidateFiles.includes(surface));
+    const uiFiles = uniqueStrings([...candidateFiles.filter(isUserFacingFile), ...impactSurfaceFiles]);
     const apiFiles = candidateFiles.filter(isApiLikeFile);
     const apiServiceSourceFiles = projectType === "api-service"
         ? candidateFiles.filter((file) => !apiFiles.includes(file) && !isConfigLikeFile(file) && isServiceSourceFile(file))
@@ -2975,11 +3068,14 @@ function buildFlowCandidates(files, runner, projectType, domainLanguage) {
     const candidates = [];
     if (uiFiles.length > 0) {
         const subject = summarizeFlowSubject(uiFiles, "Changed", domainLanguage);
+        const impactReason = importImpacts.length > 0
+            ? ` Changed shared files reach these surfaces through imports: ${importImpacts.slice(0, 3).map(describeImportChain).join("; ")}.`
+            : "";
         candidates.push({
             kind: "ui",
             title: `${subject} UI smoke flow`,
-            reason: "User-facing route, screen, navigation, or component files changed, so the draft should open the touched surface and cover the primary visible action.",
-            files: uiFiles,
+            reason: `User-facing route, screen, navigation, or component files changed, so the draft should open the touched surface and cover the primary visible action.${impactReason}`,
+            files: uniqueStrings([...uiFiles, ...importImpacts.map((impact) => impact.changedFile)]),
             steps: [
                 "Launch the app.",
                 "Navigate to the changed screen or component surface.",
@@ -3212,14 +3308,14 @@ function buildLowSignalChangeCandidate(files) {
     }
     return undefined;
 }
-async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext) {
+async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureContext, addedDiffText = {}) {
     const files = uniqueStrings(candidate.files).slice(0, 20);
     if (files.length === 0) {
         return undefined;
     }
     const coverage = buildCoverageTargets(candidate.kind, files, runner);
     const setupHints = await inferFlowSetupHints(root, files, candidate.kind);
-    const selectors = await inferFlowSelectors(root, files, runner);
+    const selectors = await inferFlowSelectors(root, files, runner, addedDiffText);
     const flow = {
         title: candidate.title,
         reason: candidate.reason,
@@ -3238,9 +3334,12 @@ async function buildFlow(root, runner, candidate, testSuiteInventory, fixtureCon
         languageBrief: buildFlowLanguageBrief(flow),
     };
 }
+function preferDiffAdded(selectors, predicate) {
+    return selectors.find((selector) => selector.addedInDiff && predicate(selector)) ?? selectors.find(predicate);
+}
 function refineStepsForInferredSelectors(steps, selectors) {
-    const inputSelector = selectors.find(isInputSelector);
-    const actionSelector = selectors.find((selector) => selectorCanDriveInteraction(selector) && !isInputSelector(selector));
+    const inputSelector = preferDiffAdded(selectors, isInputSelector);
+    const actionSelector = preferDiffAdded(selectors, (selector) => selectorCanDriveInteraction(selector) && !isInputSelector(selector));
     if (!inputSelector || !actionSelector || steps.some((step) => /^\s*(?:fill|input|enter|type|provide|write)\b/i.test(step))) {
         return steps;
     }
@@ -3257,8 +3356,8 @@ function refineStepsForInferredSelectors(steps, selectors) {
     return uniqueStrings(refined);
 }
 function refineManifestStepsForInferredSelectors(steps, selectors) {
-    const inputSelector = selectors.find(isInputSelector);
-    const actionSelector = selectors.find((selector) => selectorCanDriveInteraction(selector) && !isInputSelector(selector));
+    const inputSelector = preferDiffAdded(selectors, isInputSelector);
+    const actionSelector = preferDiffAdded(selectors, (selector) => selectorCanDriveInteraction(selector) && !isInputSelector(selector));
     if (!inputSelector || !actionSelector || steps.some(isInputStep)) {
         return steps;
     }
@@ -3280,7 +3379,12 @@ function exerciseStepSubject(step) {
     return undefined;
 }
 function selectorStepLabel(selector) {
-    return titleCase(selector.value.replace(/[-_]+/g, " "));
+    const label = titleCase(selector.value.replace(/[-_]+/g, " "));
+    if (label) {
+        return label;
+    }
+    const raw = selector.value.trim();
+    return raw.length > 0 ? `"${raw}"` : `the ${selector.kind} control`;
 }
 function actionVerbForSelector(selector) {
     if (/\b(?:submit|send|apply|complete|confirm|save|continue|next|upload)\b/i.test(selector.value.replace(/[-_]+/g, " "))) {
@@ -3588,7 +3692,8 @@ function routeSegmentsFromFileParts(parts) {
 function isBackendImplementationFile(file) {
     return /(?:^|\/)(?:server|servers|backend|api|apis|routes|controllers?|handlers?|resolvers?|endpoints?)\//i.test(file) ||
         /(?:openapi|swagger|schema|controller|handler|resolver|route)\.(?:json|ya?ml|[cm]?[jt]sx?|py|go|rs|kt|java|rb|php)$/i.test(file) ||
-        /(?:^|\/)(?:urls|views|serializers|routers|controllers?|handlers?|admin|models|services|tasks|permissions|filters)\.py$/i.test(file);
+        /(?:^|\/)(?:urls|views|viewsets|serializers|routers|controllers?|handlers?|admin|models|services|tasks|permissions|filters|consumers|signals)\w*\.py$/i.test(file) ||
+        /(?:^|\/)(?:views|viewsets|serializers|services|routers|handlers|tasks|consumers)\/[^/]+\.py$/i.test(file);
 }
 function isMockOrFixtureFile(file) {
     if (isFixtureEvidenceIgnoredPath(file)) {
@@ -3665,7 +3770,7 @@ const fixtureEvidenceIgnoredTokens = new Set([
     "test",
     "tests",
 ]);
-async function inferFlowSelectors(root, files, runner) {
+async function inferFlowSelectors(root, files, runner, addedDiffText = {}) {
     const selectors = [];
     for (const file of files.slice(0, 8)) {
         if (!isUiImplementationFile(file)) {
@@ -3675,7 +3780,10 @@ async function inferFlowSelectors(root, files, runner) {
         if (!text) {
             continue;
         }
-        selectors.push(...extractSelectorsFromText(file, text, runner));
+        const addedText = addedDiffText[file];
+        for (const selector of extractSelectorsFromText(file, text, runner)) {
+            selectors.push(addedText && addedText.includes(selector.value) ? { ...selector, addedInDiff: true } : selector);
+        }
     }
     return uniqueSelectors(selectors).slice(0, 12);
 }
@@ -4085,7 +4193,8 @@ function isUiImplementationFile(file) {
 }
 function isServiceSourceFile(file) {
     return /(?:^|\/)src\/.+\.(?:[cm]?[jt]s|py|go|rs|java|kt|cs)$/i.test(file) ||
-        /(?:^|\/)(?:urls|views|serializers|routers|controllers?|handlers?|admin|models|services|tasks|permissions|filters)\.py$/i.test(file);
+        /(?:^|\/)(?:urls|views|viewsets|serializers|routers|controllers?|handlers?|admin|models|services|tasks|permissions|filters|consumers|signals)\w*\.py$/i.test(file) ||
+        /(?:^|\/)(?:views|viewsets|serializers|services|api|apis|routers|handlers|tasks|consumers)\/[^/]+\.py$/i.test(file);
 }
 function summarizeFlowSubject(files, fallback, domainLanguage) {
     const languageSubject = summarizeFlowSubjectFromDomainLanguage(files, domainLanguage);
@@ -4338,7 +4447,7 @@ function titleCase(value) {
     return value
         .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
         .replace(/[-_]+/g, " ")
-        .replace(/[^a-zA-Z0-9 ]+/g, " ")
+        .replace(/[^\p{L}\p{N} ]+/gu, " ")
         .trim()
         .split(/\s+/)
         .filter(Boolean)
@@ -5109,12 +5218,12 @@ function draftExtension(runner) {
     }
     return ".md";
 }
-function draftContentForFlow(plan, flow, runner) {
+function draftContentForFlow(plan, flow, runner, addedDiffText = {}) {
     if (runner === "maestro") {
         return buildMaestroDraft(plan, flow);
     }
     if (runner === "playwright") {
-        return buildPlaywrightDraft(plan, flow);
+        return buildPlaywrightDraft(plan, flow, addedDiffText);
     }
     return buildManualDraft(plan, flow);
 }
@@ -5207,7 +5316,7 @@ function maestroCommandForStep(step, selectors) {
         value: maestroSelectorValue(selector),
     };
 }
-function buildPlaywrightDraft(plan, flow) {
+function buildPlaywrightDraft(plan, flow, addedDiffText = {}) {
     const testName = flow.title.replaceAll('"', "'");
     const selectorQueue = [...flow.selectors];
     const scenario = domainScenarioForFlow(flow);
@@ -5264,6 +5373,7 @@ function buildPlaywrightDraft(plan, flow) {
                 : playwrightFallbackActionForStep(step));
         appendPlaywrightTestStep(lines, step, body);
     }
+    appendObservedResponseAssertion(lines, flow, addedDiffText);
     appendDomainScenarioComments(lines, flow, "  //");
     appendPlaywrightCoverageComments(lines, flow);
     lines.push("});");
@@ -5861,12 +5971,7 @@ function appendPlaywrightMockRouteScaffold(lines, flow) {
     if (flow.fixtureReadiness.status === "not-needed" || flow.fixtureReadiness.apiEndpoints.length === 0) {
         return;
     }
-    const changedEndpointHints = uniqueStrings(flow.fixtureReadiness.backendSignals.flatMap(apiEndpointFromBackendFile));
-    const observedEndpoints = changedEndpointHints.length > 0
-        ? changedEndpointHints
-        : flow.fixtureReadiness.backendSignals.length > 0
-            ? flow.fixtureReadiness.apiEndpoints
-            : [];
+    const observedEndpoints = observedEndpointsForFlow(flow);
     if (observedEndpoints.length > 0) {
         appendPlaywrightApiObservationScaffold(lines, observedEndpoints);
     }
@@ -5899,6 +6004,66 @@ function appendPlaywrightMockRouteScaffold(lines, flow) {
     lines.push("    });");
     lines.push("  }");
 }
+function observedEndpointsForFlow(flow) {
+    if (flow.fixtureReadiness.status === "not-needed" || flow.fixtureReadiness.apiEndpoints.length === 0) {
+        return [];
+    }
+    const changedEndpointHints = uniqueStrings(flow.fixtureReadiness.backendSignals.flatMap(apiEndpointFromBackendFile));
+    if (changedEndpointHints.length > 0) {
+        return changedEndpointHints;
+    }
+    return flow.fixtureReadiness.backendSignals.length > 0 ? flow.fixtureReadiness.apiEndpoints : [];
+}
+function collectChangedHandlerEvidence(flow, addedDiffText) {
+    const statuses = [];
+    const responseKeys = [];
+    for (const file of flow.fixtureReadiness.backendSignals) {
+        const addedText = addedDiffText[file];
+        if (!addedText) {
+            continue;
+        }
+        for (const match of addedText.matchAll(/(?:status[:(]\s*|\.status\(\s*)(\d{3})\b/g)) {
+            const status = Number(match[1]);
+            if (status >= 100 && status < 600) {
+                statuses.push(status);
+            }
+        }
+        for (const match of addedText.matchAll(/(?:NextResponse|Response|res)\.json\(\s*\{([^}]{1,200})\}/g)) {
+            for (const keyMatch of match[1].matchAll(/(?:^|[,{])\s*([A-Za-z_$][\w$]*)\s*[:,}]/g)) {
+                responseKeys.push(keyMatch[1]);
+            }
+        }
+    }
+    const uniqueStatuses = [...new Set(statuses)];
+    return {
+        statuses: uniqueStatuses,
+        successOnly: uniqueStatuses.length > 0 && uniqueStatuses.every((status) => status < 400),
+        responseKeys: [...new Set(responseKeys)].slice(0, 6),
+    };
+}
+function appendObservedResponseAssertion(lines, flow, addedDiffText) {
+    if (observedEndpointsForFlow(flow).length === 0) {
+        return;
+    }
+    const evidence = collectChangedHandlerEvidence(flow, addedDiffText);
+    const statusCeiling = evidence.successOnly ? 400 : 500;
+    lines.push("");
+    if (evidence.successOnly) {
+        lines.push(`  // The added handler code only shows success statuses (${evidence.statuses.join(", ")}), so any 4xx/5xx here is unexpected.`);
+    }
+    else {
+        lines.push("  // Changed-endpoint check: the journey must not surface server errors from the code under test.");
+    }
+    if (evidence.responseKeys.length > 0) {
+        lines.push(`  // Response shape hint from the changed handler: { ${evidence.responseKeys.join(", ")} } — assert on these fields when promoting this draft.`);
+    }
+    lines.push("  for (const response of observedChangedApiResponses) {");
+    lines.push(`    expect(response.status, \`unexpected status from \${response.url}\`).toBeLessThan(${statusCeiling});`);
+    lines.push("  }");
+    lines.push("  if (observedChangedApiResponses.length === 0) {");
+    lines.push('    console.warn("Changed endpoints were not exercised by this draft; extend the steps above to cover them.");');
+    lines.push("  }");
+}
 function appendPlaywrightApiObservationScaffold(lines, endpoints) {
     lines.push("");
     lines.push("  const changedApiEndpointPatterns = [");
@@ -6248,42 +6413,56 @@ function formatMaestroCommand(command) {
     }
     return [`- ${command.kind}: ${command.value}`];
 }
+function takePreferredSelector(selectors, predicate, diffGate = predicate) {
+    let firstIndex = -1;
+    for (let index = 0; index < selectors.length; index += 1) {
+        const selector = selectors[index];
+        if (!predicate(selector)) {
+            continue;
+        }
+        if (selector.addedInDiff && diffGate(selector)) {
+            return selectors.splice(index, 1)[0];
+        }
+        if (firstIndex === -1) {
+            firstIndex = index;
+        }
+    }
+    return firstIndex >= 0 ? selectors.splice(firstIndex, 1)[0] : undefined;
+}
 function takeSelectorForStep(selectors, step) {
     if (/^launch\b/i.test(step)) {
         return undefined;
     }
     if (isInputStep(step)) {
-        const inputIndex = selectors.findIndex((selector) => isInputSelector(selector) && selectorMatchesStep(selector, step));
-        if (inputIndex >= 0) {
-            const [selector] = selectors.splice(inputIndex, 1);
-            return selector;
+        const matched = takePreferredSelector(selectors, (selector) => isInputSelector(selector) && selectorMatchesStep(selector, step));
+        if (matched) {
+            return matched;
         }
-        const fallbackInputIndex = selectors.findIndex(isInputSelector);
-        if (fallbackInputIndex >= 0) {
-            const [selector] = selectors.splice(fallbackInputIndex, 1);
-            return selector;
+        const fallbackInput = takePreferredSelector(selectors, isInputSelector);
+        if (fallbackInput) {
+            return fallbackInput;
         }
     }
     if (!isInteractionStep(step) && !isVerificationStep(step) && !canUsePrimarySelector(step)) {
         return undefined;
     }
-    const index = selectors.findIndex((selector) => !isInputSelector(selector) && selectorMatchesStep(selector, step));
-    if (index >= 0) {
-        const [selector] = selectors.splice(index, 1);
-        return selector;
+    const diffGateForStep = isAssertionStep(step) || isVerificationStep(step)
+        ? selectorCanSupportAssertion
+        : selectorCanDriveInteraction;
+    const matched = takePreferredSelector(selectors, (selector) => !isInputSelector(selector) && selectorMatchesStep(selector, step), diffGateForStep);
+    if (matched) {
+        return matched;
     }
     if (isAssertionStep(step)) {
-        const assertionIndex = selectors.findIndex((selector) => selectorCanSupportAssertion(selector));
-        if (assertionIndex >= 0) {
-            const [selector] = selectors.splice(assertionIndex, 1);
-            return selector;
+        const assertion = takePreferredSelector(selectors, selectorCanSupportAssertion);
+        if (assertion) {
+            return assertion;
         }
     }
     if (canUsePrimarySelector(step)) {
-        const fallbackIndex = selectors.findIndex((selector) => selectorCanDriveInteraction(selector));
-        if (fallbackIndex >= 0) {
-            const [selector] = selectors.splice(fallbackIndex, 1);
-            return selector;
+        const fallback = takePreferredSelector(selectors, selectorCanDriveInteraction);
+        if (fallback) {
+            return fallback;
         }
     }
     return undefined;
@@ -6586,7 +6765,7 @@ function withoutSelectorValueDuplicates(selectors, existing) {
 function extractAttributeSelectors(file, text, attributes, kind) {
     const selectors = [];
     for (const attribute of attributes) {
-        const matcher = new RegExp(`${escapeRegExp(attribute)}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{\\s*["'\`]([^"'\`{}]+)["'\`]\\s*\\})`, "g");
+        const matcher = new RegExp(`(?<![:@.\\w-])${escapeRegExp(attribute)}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{\\s*["'\`]([^"'\`{}]+)["'\`]\\s*\\})`, "g");
         for (const match of text.matchAll(matcher)) {
             const value = normalizeSelectorValue(match[1] ?? match[2] ?? match[3]);
             if (value) {
@@ -6644,7 +6823,15 @@ function normalizeSelectorValue(value) {
     return normalized || undefined;
 }
 function isUsefulSelector(value) {
-    return value.length >= 2 && value.length <= 80 && !/[{}()[\]=>]/.test(value);
+    if (value.length < 2 || value.length > 80 || /[{}()[\]=>]/.test(value)) {
+        return false;
+    }
+    // Dotted tokens without spaces are almost always i18n keys or property paths,
+    // never rendered UI text, so a locator built from them can never match.
+    if (/^[\w$-]+(?:\.[\w$-]+)+$/.test(value)) {
+        return false;
+    }
+    return true;
 }
 async function readPackageJson(root) {
     try {
@@ -6654,6 +6841,77 @@ async function readPackageJson(root) {
         return undefined;
     }
 }
+const maxWorkspaceMembers = 30;
+async function collectWorkspaceMemberDependencies(root, packageJson) {
+    const patterns = await readWorkspaceMemberPatterns(root, packageJson);
+    if (patterns.length === 0) {
+        return [];
+    }
+    const memberDirectories = await expandWorkspaceMemberPatterns(root, patterns);
+    const members = [];
+    for (const directory of memberDirectories.slice(0, maxWorkspaceMembers)) {
+        const memberPackageJson = await readPackageJson(path.join(root, directory));
+        if (!memberPackageJson) {
+            continue;
+        }
+        const dependencies = {
+            ...(memberPackageJson.dependencies ?? {}),
+            ...(memberPackageJson.devDependencies ?? {}),
+        };
+        members.push({
+            directory,
+            dependencies,
+            frameworkSignals: frameworkSignalDependencies.filter((dependency) => dependency in dependencies),
+        });
+    }
+    return members;
+}
+async function readWorkspaceMemberPatterns(root, packageJson) {
+    const patterns = [];
+    const workspaces = packageJson?.workspaces;
+    if (Array.isArray(workspaces)) {
+        patterns.push(...workspaces);
+    }
+    else if (workspaces?.packages) {
+        patterns.push(...workspaces.packages);
+    }
+    const workspaceYaml = await readTextIfExists(path.join(root, "pnpm-workspace.yaml"));
+    if (workspaceYaml) {
+        try {
+            const parsed = YAML.parse(workspaceYaml);
+            patterns.push(...(parsed?.packages ?? []));
+        }
+        catch {
+            // ignore unparseable workspace config
+        }
+    }
+    return uniqueStrings(patterns.filter((pattern) => typeof pattern === "string" && !pattern.startsWith("!")));
+}
+async function expandWorkspaceMemberPatterns(root, patterns) {
+    const directories = [];
+    for (const pattern of patterns) {
+        const normalized = pattern.replace(/\/\*{1,2}$/, "");
+        if (normalized.includes("*")) {
+            continue;
+        }
+        if (normalized === pattern) {
+            directories.push(normalized);
+            continue;
+        }
+        try {
+            const entries = await fs.readdir(path.join(root, normalized), { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                    directories.push(`${normalized}/${entry.name}`);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return uniqueStrings(directories);
+}
 async function readTextIfExists(filePath) {
     try {
         return await fs.readFile(filePath, "utf8");