@sudobility/testomniac_runner_service 0.1.139 → 0.1.142

package/dist/analyzer/page-analyzer/index.js

@@ -1,149 +1,44 @@
 import { PlaywrightAction, ExpectationType, ExpectationSeverity, } from "@sudobility/testomniac_types";
 import { buildReplaySelectorFromActionableItem, matchesActionableItemSelector, } from "../../browser/replay-selector";
-import { computeHashes, computeActionableHash, sha256, normalizeHtml, htmlToMarkdown, } from "../../browser/page-utils";
-import { getBody, getContentBody } from "../../scanner/html-decomposer";
 import { createHash } from "node:crypto";
-import { fillValuePlanner } from "../../planners/fill-value-planner";
-import { AUTH_URL_PATTERNS, SIGNUP_URL_PATTERNS } from "../../config/constants";
 import { InMemoryDedupStore } from "../../storage/dedup-store";
-import { generateHoverFollowUpCases } from "./generators/hover-follow-up";
-import { generateNavigationTestInteractions } from "./generators/navigation";
-import { generateScaffoldTestInteractions } from "./generators/scaffolds";
-import { generateRenderTestInteractions } from "./generators/render";
-import { generateFormTestInteractions } from "./generators/forms";
-import { generateE2ETestInteractions } from "./generators/e2e";
-import { generateSemanticJourneyTestInteractions } from "./generators/semantic-journeys";
-import { generateDialogLifecycleTestInteractions } from "./generators/dialogs";
-import { generateKeyboardAndDisclosureTestInteractions } from "./generators/keyboard-disclosure";
-import { generateVariantTestInteractions } from "./generators/variants";
-import { generateContentTestInteractions } from "./generators/content";
-import { generateLoginTestInteractions } from "./generators/login";
 function logAnalyzer(step, details) {
     console.info("[PageAnalyzer]", step, details ?? {});
 }
 /**
- * Normalize a URL path for dedup comparison:
- *  1. Remove query params with empty values (`foo=` or `foo`)
- *  2. Sort remaining params so order doesn't matter
+ * PageAnalyzer provides finding dedup, expectation generation, and
+ * hover-to-click transformation during discovery mode.
  *
- * `/store/?b=2&a=1` and `/store/?a=1&b=2` → same key.
- * `/store/?filternum=0&pagenum=1` keeps both (non-empty values).
- * `/store/?foo=&bar` drops both (empty values).
- */
-function normalizePathForDedup(raw) {
-    const qIndex = raw.indexOf("?");
-    if (qIndex === -1)
-        return raw;
-    const base = raw.slice(0, qIndex);
-    const search = raw.slice(qIndex + 1);
-    if (!search)
-        return base;
-    const kept = search
-        .split("&")
-        .filter(pair => {
-        const eqIndex = pair.indexOf("=");
-        if (eqIndex === -1)
-            return false; // bare key, no value
-        return pair.slice(eqIndex + 1).length > 0; // non-empty value
-    })
-        .sort();
-    return kept.length > 0 ? `${base}?${kept.join("&")}` : base;
-}
-/** Strip the query string entirely to get the base path. */
-function basePathOf(raw) {
-    const qIndex = raw.indexOf("?");
-    return qIndex === -1 ? raw : raw.slice(0, qIndex);
-}
-/**
- * PageAnalyzer generates expectations and discovers new test elements
- * during discovery mode.
+ * Test generators have been moved server-side to testomniac_api.
  */
 export class PageAnalyzer {
     store;
-    surfacesCache = null;
     constructor(dedupStore) {
         this.store = dedupStore ?? new InMemoryDedupStore();
     }
-    async getCachedSurfaces(context) {
-        if (!this.surfacesCache) {
-            this.surfacesCache = await context.api.getTestSurfacesByRunner(context.runnerId);
-        }
-        return this.surfacesCache;
-    }
-    invalidateSurfacesCache() {
-        this.surfacesCache = null;
-    }
-    /** Check whether generation already happened for a given path in this run. */
-    hasGeneratedForPath(path) {
-        return this.store.has("generatedPaths", normalizePathForDedup(path));
-    }
-    /**
-     * Check whether a (actionType, replaySelector) pair has already been
-     * generated for any URL variant of the same base path.
-     */
-    hasGeneratedSelectorForBasePath(path, actionType, replaySelector) {
-        const key = `${basePathOf(path)}\0${actionType}\0${replaySelector}`;
-        return this.store.has("generatedSelectors", key);
-    }
-    /**
-     * Record that a (actionType, replaySelector) was generated under a base
-     * path so future URL variants can skip it.
-     */
-    markGeneratedSelectorForBasePath(path, actionType, replaySelector) {
-        const key = `${basePathOf(path)}\0${actionType}\0${replaySelector}`;
-        return this.store.add("generatedSelectors", key);
-    }
-    /**
-     * Normalize finding text for dedup: strip leading count numbers that vary
-     * between evaluations.  Preserves URLs, status codes, and other content.
-     *
-     *   "[page-health] 5 broken image(s)" → "[page-health] broken image(s)"
-     *   "3 significant console warning(s)" → "significant console warning(s)"
-     *   "Page returned HTTP 404 for …"    → unchanged
-     */
     static normalizeFindingText(text) {
         return text.replace(/^(\[[^\]]+\]\s*)\d+\s+/, "$1").replace(/^\d+\s+/, "");
     }
-    /**
-     * Returns true if an equivalent page-scoped finding has already been
-     * recorded during this run.
-     */
     hasReportedPageFinding(_path, title, description) {
         const key = `${PageAnalyzer.normalizeFindingText(title)}\0${PageAnalyzer.normalizeFindingText(description)}`;
         return this.store.has("reportedPageFindings", key);
     }
-    /**
-     * Mark a page-scoped finding as recorded so it is not duplicated.
-     */
     markPageFindingReported(_path, title, description) {
         const key = `${PageAnalyzer.normalizeFindingText(title)}\0${PageAnalyzer.normalizeFindingText(description)}`;
         return this.store.add("reportedPageFindings", key);
     }
-    /** Check whether a finding with the given stable key has been reported. */
     hasReportedFindingByKey(key) {
         return this.store.has("reportedFindingKeys", key);
     }
-    /** Mark a stable finding key as reported. */
     markReportedFindingByKey(key) {
         return this.store.add("reportedFindingKeys", key);
     }
-    /**
-     * Check if a finding with this description has already been reported.
-     */
     hasReportedDescription(description) {
         return this.store.has("reportedDescriptions", PageAnalyzer.normalizeFindingText(description));
     }
-    /** Mark a finding description as reported. */
     markReportedDescription(description) {
         return this.store.add("reportedDescriptions", PageAnalyzer.normalizeFindingText(description));
     }
-    /**
-     * Check whether full test generation already ran for a page state with the
-     * same visible actionable items (by hash).
-     */
-    hasGeneratedForActionableHash(hash) {
-        return this.store.has("generatedActionableHashes", hash);
-    }
     /**
      * Generate baseline expectations for a test element.
      * Called BEFORE expertises evaluate.
@@ -272,273 +167,11 @@ export class PageAnalyzer {
      * Generate new test elements for scaffolds and page content.
      * Called AFTER expertises evaluate and the target page state is established.
      */
-    async generateTestInteractions(testInteraction, context) {
-        logAnalyzer("generate:start", {
-            sourceTitle: testInteraction.title,
-            sourceType: testInteraction.type,
-            sourcePriority: testInteraction.priority,
-            sourceSurfaceTags: testInteraction.surface_tags,
-            currentTestInteractionId: context.currentTestInteractionId,
-            currentTestSurfaceId: context.currentTestSurfaceId,
-            currentSurfaceRunId: context.currentSurfaceRunId ?? null,
-            beginningPageStateId: context.beginningPageStateId,
-            currentPageStateId: context.currentPageStateId,
-            currentPath: context.currentPath,
-            actionableItemsCount: context.actionableItems.length,
-            formsCount: context.forms.length,
-            scaffoldsCount: context.scaffolds.length,
-        });
-        // Skip generation if the current path is outside the scan scope boundary
-        if (context.scanScopePath &&
-            !context.currentPath.startsWith(context.scanScopePath)) {
-            logAnalyzer("generate:out-of-scope", {
-                sourceTitle: testInteraction.title,
-                currentPath: context.currentPath,
-                scanScopePath: context.scanScopePath,
-            });
-            return;
-        }
-        const normalizedContext = this.normalizeContext(context);
-        const isHover = this.isHoverOnly(testInteraction);
-        const currentPath = normalizedContext.currentPath.trim();
-        const dedupPath = normalizePathForDedup(currentPath);
-        // For non-hover interactions: check cheap path/hash guards BEFORE the
-        // expensive ensureTargetPageState call so we can skip all the API work
-        // (scaffold resolution, hash computation, page-state creation) when the
-        // page has already been covered in this run.
-        if (!isHover) {
-            if (await this.store.has("generatedPaths", dedupPath)) {
-                logAnalyzer("generate:page-already-covered", {
-                    sourceTitle: testInteraction.title,
-                    currentTestInteractionId: normalizedContext.currentTestInteractionId,
-                    currentPath,
-                    dedupPath,
-                });
-                return;
-            }
-            const actionableHash = await computeActionableHash(normalizedContext.actionableItems);
-            if (await this.store.has("generatedActionableHashes", actionableHash)) {
-                logAnalyzer("generate:actionable-items-already-covered", {
-                    sourceTitle: testInteraction.title,
-                    currentTestInteractionId: normalizedContext.currentTestInteractionId,
-                    currentPath,
-                    actionableHash,
-                });
-                return;
-            }
-        }
-        const currentPageStateId = await this.ensureTargetPageState(normalizedContext);
-        const resolvedContext = {
-            ...normalizedContext,
-            currentPageStateId,
-        };
-        logAnalyzer("generate:resolved-context", {
-            sourceTitle: testInteraction.title,
-            sourceType: testInteraction.type,
-            currentTestInteractionId: resolvedContext.currentTestInteractionId,
-            currentTestSurfaceId: resolvedContext.currentTestSurfaceId,
-            currentSurfaceRunId: resolvedContext.currentSurfaceRunId ?? null,
-            beginningPageStateId: resolvedContext.beginningPageStateId,
-            currentPageStateId: resolvedContext.currentPageStateId,
-            currentPath: resolvedContext.currentPath,
-        });
-        // Hover-only interactions have their own same-page-state handling inside
-        // generateHoverFollowUpCases (including click-follow-up reconciliation),
-        // so let them through to that dedicated path.
-        if (isHover) {
-            logAnalyzer("generate:hover-only", {
-                sourceTitle: testInteraction.title,
-                currentTestInteractionId: resolvedContext.currentTestInteractionId,
-                currentPageStateId: resolvedContext.currentPageStateId,
-            });
-            await generateHoverFollowUpCases(this, testInteraction, resolvedContext);
-            return;
-        }
-        // For non-hover interactions: skip generation when the end page state is
-        // the same as the starting page state — the interaction did not cause a
-        // meaningful change, so there is nothing new to discover or test.
-        if (resolvedContext.beginningPageStateId > 0 &&
-            currentPageStateId === resolvedContext.beginningPageStateId) {
-            logAnalyzer("generate:same-page-state", {
-                sourceTitle: testInteraction.title,
-                currentTestInteractionId: resolvedContext.currentTestInteractionId,
-                currentPageStateId,
-                beginningPageStateId: resolvedContext.beginningPageStateId,
-            });
-            return;
-        }
-        // Re-check actionableHash (already passed the guard above, but we need
-        // to record it and the path now that we're committed to generation).
-        const actionableHash = await computeActionableHash(resolvedContext.actionableItems);
-        // Only mark the path as covered if actionable items were found.
-        // If the page hadn't fully loaded yet (e.g. SPA hydration), the first
-        // pass may see 0 items.  Keeping the path open lets a later test
-        // (Render, which waits for load state) re-run the full generation pass
-        // with the complete HTML.
-        if (resolvedContext.actionableItems.length > 0) {
-            await this.store.add("generatedPaths", dedupPath);
-            await this.store.add("generatedActionableHashes", actionableHash);
-        }
-        // If a hover+click navigated to a new page, create a direct navigation
-        // interaction and use it as the dependency instead of the hover chain
-        let contextForFullPass = resolvedContext;
-        const normalizedStartingPath = (testInteraction.startingPath || "/").trim();
-        if (this.isHoverBased(testInteraction) &&
-            normalizedStartingPath !== currentPath) {
-            const navInteraction = this.buildNavigationTestInteraction(currentPath, resolvedContext.sizeClass, resolvedContext.uid, resolvedContext.currentPageStateId > 0
-                ? resolvedContext.currentPageStateId
-                : undefined);
-            const navSurfaceId = resolvedContext.navigationSurface.id;
-            const saved = await resolvedContext.api.ensureTestInteraction(resolvedContext.runnerId, navSurfaceId, navInteraction, resolvedContext.testEnvironmentId);
-            // Also create a run for it so the runner can execute it
-            const surfaceRuns = await resolvedContext.api.getOpenTestSurfaceRuns(resolvedContext.bundleRun.id);
-            const navSurfaceRun = surfaceRuns.find(sr => sr.testSurfaceId === navSurfaceId);
-            if (navSurfaceRun) {
-                try {
-                    await resolvedContext.api.createTestInteractionRun({
-                        testInteractionId: saved.id,
-                        testSurfaceRunId: navSurfaceRun.id,
-                    });
-                }
-                catch (err) {
-                    // Run may already exist
-                    logAnalyzer("create-interaction-run:skipped", {
-                        reason: "may already exist",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-            logAnalyzer("generate:navigation-dependency-created", {
-                sourceTitle: testInteraction.title,
-                navigationInteractionId: saved.id,
-                navigationPath: currentPath,
-                originalDependencyId: resolvedContext.currentTestInteractionId,
-            });
-            contextForFullPass = {
-                ...resolvedContext,
-                currentTestInteractionId: saved.id,
-            };
-        }
-        logAnalyzer("generate:full-pass", {
-            sourceTitle: testInteraction.title,
-            currentTestInteractionId: contextForFullPass.currentTestInteractionId,
-            currentPageStateId: contextForFullPass.currentPageStateId,
-        });
-        // Collect all standard generator outputs (they return data, no API calls)
-        const outputs = [];
-        outputs.push(await generateRenderTestInteractions(this, contextForFullPass));
-        outputs.push(await generateFormTestInteractions(this, contextForFullPass));
-        // Login test generation: calls API directly (dependency chains)
-        if (contextForFullPass.loginDetection?.isLoginPage) {
-            await generateLoginTestInteractions(this, contextForFullPass, contextForFullPass.loginDetection, contextForFullPass.loginConfig);
-        }
-        outputs.push(await generateSemanticJourneyTestInteractions(this, contextForFullPass));
-        outputs.push(await generateE2ETestInteractions(this, contextForFullPass));
-        outputs.push(await generateDialogLifecycleTestInteractions(this, contextForFullPass));
-        outputs.push(await generateScaffoldTestInteractions(this, contextForFullPass));
-        outputs.push(await generateContentTestInteractions(this, contextForFullPass));
-        outputs.push(await generateKeyboardAndDisclosureTestInteractions(this, contextForFullPass));
-        outputs.push(await generateVariantTestInteractions(this, contextForFullPass));
-        // Batch all collected generator outputs in one API call
-        const allCreates = outputs.flatMap(o => o.creates);
-        const allReconciles = outputs.flatMap(o => o.reconciles);
-        if (allCreates.length > 0 || allReconciles.length > 0) {
-            const batchResult = await contextForFullPass.api.generateAllSurfaceInteractions({
-                runnerId: contextForFullPass.runnerId,
-                testEnvironmentId: contextForFullPass.testEnvironmentId,
-                sizeClass: contextForFullPass.sizeClass,
-                testSurfaceBundleId: contextForFullPass.bundleRun.testSurfaceBundleId,
-                testSurfaceBundleRunId: contextForFullPass.bundleRun.id,
-                surfaces: allCreates,
-                reconcileOnly: allReconciles,
-            });
-            // Emit events for all created surfaces
-            for (const item of batchResult.results) {
-                contextForFullPass.events.onTestSurfaceCreated({
-                    surfaceId: item.surface.id,
-                    title: item.surface.title,
-                });
-            }
-        }
-        // Navigation calls API directly (no surface creation, no reconcile)
-        await generateNavigationTestInteractions(this, contextForFullPass);
-    }
-    async reconcileGeneratedSurfaceElements(context, params) {
-        let surfaceId;
-        if (params.surfaceId != null) {
-            surfaceId = params.surfaceId;
-        }
-        else {
-            const surface = await this.findExistingSurfaceByTitle(context, params.surfaceTitle);
-            if (!surface) {
-                logAnalyzer("reconcile:surface-missing", {
-                    requestedSurfaceId: params.surfaceId ?? null,
-                    requestedSurfaceTitle: params.surfaceTitle,
-                    dependencyTestInteractionId: params.dependencyTestInteractionId ?? null,
-                    desiredKeysCount: params.desiredKeys.length,
-                });
-                return;
-            }
-            surfaceId = surface.id;
-        }
-        const result = await context.api.reconcileTestInteractions({
-            testSurfaceId: surfaceId,
-            desiredKeys: params.desiredKeys,
-            dependencyTestInteractionId: params.dependencyTestInteractionId,
-        });
-        logAnalyzer("reconcile:completed", {
-            surfaceId,
-            surfaceTitle: params.surfaceTitle,
-            dependencyTestInteractionId: params.dependencyTestInteractionId ?? null,
-            desiredKeysCount: params.desiredKeys.length,
-            retiredIds: result.retiredIds,
-        });
-    }
-    async findExistingSurfaceByTitle(context, title) {
-        const surfaces = await this.getCachedSurfaces(context);
-        const surface = surfaces.find(candidate => candidate.title === title);
-        return surface ? { id: surface.id, title: surface.title } : null;
-    }
-    getScaffoldSurfaceItems(context, scaffold) {
-        return this.normalizeActionableItems(context.actionableItems).filter(item => {
-            if (!this.isSurfaceCandidate(item) || !item.selector)
-                return false;
-            return (context.scaffoldSelectorByItemSelector[item.selector] ===
-                scaffold.selector);
-        });
-    }
-    async ensureSurfaceRun(api, testSurfaceId, bundleRunId) {
-        const openSurfaceRuns = await api.getOpenTestSurfaceRuns(bundleRunId);
-        const existing = openSurfaceRuns.find(surfaceRun => surfaceRun.testSurfaceId === testSurfaceId);
-        if (existing) {
-            logAnalyzer("surface-run:reused", {
-                bundleRunId,
-                testSurfaceId,
-                surfaceRunId: existing.id,
-            });
-            return existing;
-        }
-        const created = await api.createTestSurfaceRun({
-            testSurfaceId,
-            testSurfaceBundleRunId: bundleRunId,
-        });
-        logAnalyzer("surface-run:created", {
-            bundleRunId,
-            testSurfaceId,
-            surfaceRunId: created.id,
-        });
-        return created;
-    }
     isMouseActionable(item) {
         return (item.visible &&
             !item.disabled &&
             (item.actionKind === "click" || item.actionKind === "navigate"));
     }
-    /**
-     * Returns true if the item is a link with a non-browser protocol (mailto:,
-     * tel:, ftp:, etc.).  Clicking such links launches external applications
-     * which cannot be controlled or closed by the test runner.
-     */
     isNonBrowserLink(item) {
         if (!item.href)
             return false;
@@ -553,81 +186,6 @@ export class PageAnalyzer {
         // Anything with a scheme that isn't http/https is non-browser
         return /^[a-z][a-z0-9+.-]*:/i.test(href);
     }
-    isSurfaceCandidate(item) {
-        if (!item.visible || !item.selector || item.disabled)
-            return false;
-        return ["click", "navigate", "fill", "select", "radio_select"].includes(item.actionKind);
-    }
-    extractRelativePath(href) {
-        try {
-            const url = new URL(href, "http://placeholder");
-            return url.pathname + url.search;
-        }
-        catch (err) {
-            logAnalyzer("extract-relative-path:failed", {
-                href,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return null;
-        }
-    }
-    buildNavigationTestInteraction(path, sizeClass, uid, startingPageStateId) {
-        return {
-            title: `Navigate to ${path}`,
-            type: "navigation",
-            sizeClass,
-            surface_tags: ["navigation"],
-            priority: 3,
-            startingPageStateId,
-            startingPath: path,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Goto,
-                        path,
-                        playwrightCode: `await page.goto('${path}')`,
-                        description: `Navigate to ${path}`,
-                    },
-                    expectations: [],
-                    description: `Navigate to ${path}`,
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: [],
-            uid,
-            generatedKey: this.buildGeneratedKey("navigation", startingPageStateId, path),
-        };
-    }
-    buildHoverTestInteraction(item, startingPath, sizeClass, uid, startingPageStateId, dependencyTestInteractionId) {
-        const label = this.describeActionableItem(item);
-        const replaySelector = buildReplaySelectorFromActionableItem(item);
-        return {
-            title: `Hover over ${label}`,
-            type: "interaction",
-            sizeClass,
-            surface_tags: ["interaction", "hover"],
-            priority: 1,
-            dependencyTestInteractionId,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Hover,
-                        path: replaySelector,
-                        playwrightCode: `await page.hover('${replaySelector}')`,
-                        description: `Hover over ${label}`,
-                    },
-                    expectations: [],
-                    description: `Hover over ${label}`,
-                    continueOnFailure: true,
-                },
-            ],
-            globalExpectations: [],
-            uid,
-            generatedKey: this.buildGeneratedKey("hover", startingPageStateId, dependencyTestInteractionId, replaySelector),
-        };
-    }
     buildClickTestInteraction(item, startingPath, sizeClass, uid, startingPageStateId, dependencyTestInteractionId) {
         const label = this.describeActionableItem(item);
         const replaySelector = buildReplaySelectorFromActionableItem(item);
@@ -665,13 +223,6 @@ export class PageAnalyzer {
         return (steps.length === 1 &&
             steps[0]?.action?.actionType === PlaywrightAction.Hover);
     }
-    isHoverBased(testInteraction) {
-        const steps = Array.isArray(testInteraction.steps)
-            ? testInteraction.steps
-            : [];
-        return (steps.length > 0 &&
-            steps[0]?.action?.actionType === PlaywrightAction.Hover);
-    }
     getPrimarySelector(testInteraction) {
         const steps = Array.isArray(testInteraction.steps)
             ? testInteraction.steps
@@ -684,22 +235,6 @@ export class PageAnalyzer {
         const selector = item.selector;
         return stableKey ?? selector ?? null;
     }
-    withGeneratedKey(testInteraction, ...parts) {
-        return {
-            ...testInteraction,
-            generatedKey: this.buildGeneratedKey(...parts),
-        };
-    }
-    getGeneratedKey(testInteraction) {
-        return (testInteraction.generatedKey?.trim() || testInteraction.title).trim();
-    }
-    getPersistedGeneratedKey(testInteraction) {
-        const generatedKey = testInteraction.generatedKey?.trim();
-        if (generatedKey)
-            return generatedKey;
-        const title = testInteraction.title?.trim();
-        return title || null;
-    }
     buildGeneratedKey(...parts) {
         const normalized = parts
             .map(part => (part == null ? "" : String(part).trim()))
@@ -717,1821 +252,122 @@ export class PageAnalyzer {
             .slice(0, 80);
         return prefix ? `${prefix}:${digest}` : digest;
     }
-    buildStepSignature(steps) {
-        return steps
-            .map(step => [
-            step.action?.actionType ?? "",
-            step.action?.path ?? "",
-            step.action?.value ?? "",
-            step.action?.description ?? "",
-        ].join("|"))
-            .join("||");
-    }
-    async ensureTargetPageState(context) {
-        // Fast path: page state already known — just link scaffolds
-        if (context.currentPageStateId > 0) {
-            const scaffoldIdsBySelector = await this.ensureScaffolds(context);
-            for (const item of context.actionableItems) {
-                if (!item.selector)
-                    continue;
-                const scaffoldSelector = context.scaffoldSelectorByItemSelector[item.selector] ?? null;
-                if (!scaffoldSelector)
-                    continue;
-                const scaffoldId = scaffoldIdsBySelector.get(scaffoldSelector);
-                if (scaffoldId) {
-                    item.scaffoldId = scaffoldId;
-                }
-            }
-            if (scaffoldIdsBySelector.size > 0) {
-                await context.api.linkPageStateScaffolds(context.currentPageStateId, Array.from(new Set(scaffoldIdsBySelector.values())));
-            }
-            context.events.onPageStateCreated({
-                pageStateId: context.currentPageStateId,
-                pageId: context.pageId,
-            });
-            await this.ensureStoredForms(context.currentPageStateId, context);
-            return context.currentPageStateId;
-        }
-        // Combined endpoint: scaffolds + match + create in one round-trip
-        const hashes = await computeHashes(context.html, context.actionableItems);
-        let fixedBodyHash;
-        if (context.scaffolds.length > 0) {
-            const body = getBody(context.html);
-            const { contentBody } = getContentBody(body, context.scaffolds);
-            fixedBodyHash = await sha256(normalizeHtml(contentBody));
-        }
-        const result = await context.api.ensurePageStateCombined({
-            pageId: context.pageId > 0 ? context.pageId : undefined,
-            relativePath: context.pageId === 0 ? context.currentPath : undefined,
-            runnerId: context.runnerId,
-            testEnvironmentId: context.testEnvironmentId,
-            sizeClass: context.sizeClass,
-            screenshotPath: context.screenshotPath,
-            html: context.html,
-            contentText: htmlToMarkdown(context.html).slice(0, 5000),
-            hashes,
-            fixedBodyHash,
-            actionableItems: context.actionableItems,
-            scaffolds: context.scaffolds.map(scaffold => ({
-                type: scaffold.type,
-                html: scaffold.outerHtml,
-                hash: scaffold.hash,
-                selector: scaffold.selector,
-            })),
-            scaffoldSelectorByItemSelector: context.scaffoldSelectorByItemSelector,
-        });
-        // Part A: server resolved the page — update context
-        if (result.pageId && context.pageId === 0) {
-            context.pageId = result.pageId;
-            context.pageRequiresLogin = result.requiresLogin;
+    describeActionableItem(item) {
+        const described = (item.accessibleName ||
+            item.textContent ||
+            String(item.attributes?._containerTitle ?? "") ||
+            String(item.attributes?.labelText ?? "") ||
+            String(item.attributes?.placeholder ?? "")).trim();
+        if (described)
+            return described;
+        const selector = item.selector ?? "";
+        if (selector.includes("data-tmnc-id")) {
+            const role = item.role?.trim();
+            const inputType = item.inputType?.trim();
+            if (role)
+                return role;
+            if (inputType)
+                return inputType;
+            if (item.actionKind === "navigate")
+                return "link";
+            if (item.actionKind === "fill")
+                return "input";
+            if (item.actionKind === "select")
+                return "select";
+            return "control";
         }
-        // Map scaffold IDs back to in-memory actionable items for generators
-        for (const item of context.actionableItems) {
-            if (!item.selector)
-                continue;
-            const scaffoldSelector = context.scaffoldSelectorByItemSelector[item.selector] ?? null;
-            if (!scaffoldSelector)
+        return selector || item.actionKind || "control";
+    }
+    semanticText(item) {
+        return [
+            item.accessibleName || "",
+            item.textContent || "",
+            String(item.attributes?.labelText ?? ""),
+            String(item.attributes?.placeholder ?? ""),
+            String(item.attributes?.name ?? ""),
+            String(item.attributes?.id ?? ""),
+            String(item.attributes?._containerTitle ?? ""),
+            String(item.attributes?._containerCtaStyle ?? ""),
+            item.href || "",
+            item.selector,
+        ]
+            .join(" ")
+            .toLowerCase();
+    }
+    /**
+     * Max representatives per action style.  Product grids can have dozens of
+     * cards each producing a unique container fingerprint (because the product
+     * title differs), but the CTA buttons ("ADD TO CART", "Select Options") are
+     * functionally identical.  Capping per style prevents 14× duplicate hover
+     * tests for the same button type across different cards.
+     */
+    static MAX_REPS_PER_STYLE = 2;
+    selectRepresentativeItems(items, maxPerStyle = PageAnalyzer.MAX_REPS_PER_STYLE) {
+        const groups = new Map();
+        const passthrough = [];
+        for (const item of items) {
+            const containerFingerprint = String(item.attributes?._containerFingerprint ?? "").trim();
+            if (!containerFingerprint) {
+                passthrough.push(item);
                 continue;
-            const scaffoldId = result.scaffoldIdsBySelector[scaffoldSelector];
-            if (scaffoldId) {
-                item.scaffoldId = scaffoldId;
             }
+            const key = `${containerFingerprint}|${this.representativeActionStyle(item)}`;
+            const bucket = groups.get(key) ?? [];
+            bucket.push(item);
+            groups.set(key, bucket);
         }
-        // Scaffold screenshots are now updated server-side in ensure-page-state
-        context.events.onPageStateCreated({
-            pageStateId: result.pageStateId,
-            pageId: result.pageId ?? context.pageId,
-        });
-        await this.ensureStoredForms(result.pageStateId, context);
-        return result.pageStateId;
-    }
-    async ensureScaffolds(context) {
-        const scaffoldIdsBySelector = new Map();
-        if (context.scaffolds.length === 0)
-            return scaffoldIdsBySelector;
-        const items = context.scaffolds.map(scaffold => ({
-            runnerId: context.runnerId,
-            type: scaffold.type,
-            html: scaffold.outerHtml,
-            hash: scaffold.hash,
-        }));
-        const results = await context.api.findOrCreateScaffoldBatch(items);
-        for (let i = 0; i < context.scaffolds.length; i++) {
-            const scaffold = context.scaffolds[i];
-            const result = results[i];
-            scaffoldIdsBySelector.set(scaffold.selector, result.id);
-            // Link page state screenshot to scaffold if it doesn't have one
-            if (!result.screenshotPath && context.screenshotPath) {
-                try {
-                    await context.api.updateScaffoldScreenshot(result.id, context.screenshotPath);
-                }
-                catch {
-                    // Best effort — scaffold screenshot is optional
-                }
-            }
+        const representatives = Array.from(groups.values()).map(group => this.pickRepresentativeItem(group));
+        // Cap per action style: when many different containers share the same
+        // functional action (e.g. 14 product cards each with "ADD TO CART"),
+        // keep at most maxPerStyle representatives per style.
+        // Include passthrough items in the cap — items without a container
+        // fingerprint (e.g. product links in a grid that wasn't detected as a
+        // repeated container) should still be deduplicated by functional style.
+        const allCandidates = [...passthrough, ...representatives];
+        const byStyle = new Map();
+        for (const rep of allCandidates) {
+            const style = this.representativeActionStyle(rep);
+            const bucket = byStyle.get(style) ?? [];
+            bucket.push(rep);
+            byStyle.set(style, bucket);
         }
-        return scaffoldIdsBySelector;
+        return Array.from(byStyle.values()).flatMap(group => group.length <= maxPerStyle ? group : group.slice(0, maxPerStyle));
     }
-    async ensureStoredForms(pageStateId, context) {
-        const forms = this.normalizeForms(context.forms);
-        if (forms.length === 0)
-            return;
-        const existing = await context.api.getFormsByPageState(pageStateId);
-        const existingSelectors = new Set(existing.map(form => form.selector));
-        for (const form of forms) {
-            if (existingSelectors.has(form.selector))
-                continue;
-            await context.api.insertForm(pageStateId, form, this.identifyFormType(form, context.currentPath));
+    representativeActionStyle(item) {
+        const text = this.semanticText(item);
+        const sourceHints = String(item.attributes?._sourceHints ?? "").toLowerCase();
+        const containerTitle = String(item.attributes?._containerTitle ?? "").toLowerCase();
+        if (sourceHints.includes("promoted-target") ||
+            sourceHints.includes("cursor-pointer")) {
+            return "tile-click";
         }
-    }
-    normalizeContext(context) {
-        return {
-            ...context,
-            html: typeof context.html === "string" ? context.html : "",
-            scaffolds: Array.isArray(context.scaffolds) ? context.scaffolds : [],
-            scaffoldSelectorByItemSelector: context.scaffoldSelectorByItemSelector &&
-                typeof context.scaffoldSelectorByItemSelector === "object"
-                ? context.scaffoldSelectorByItemSelector
-                : {},
-            actionableItems: this.normalizeActionableItems(context.actionableItems),
-            forms: this.normalizeForms(context.forms),
-            journeySteps: Array.isArray(context.journeySteps)
-                ? context.journeySteps
-                : [],
-        };
-    }
-    normalizeActionableItems(items) {
-        return Array.isArray(items) ? items : [];
-    }
-    normalizeForms(forms) {
-        return Array.isArray(forms) ? forms : [];
-    }
-    buildRenderTestInteraction(currentPath, sizeClass, uid, startingPageStateId, pageId) {
-        return {
-            title: `Render — ${currentPath}`,
-            type: "render",
-            sizeClass,
-            surface_tags: ["render"],
-            priority: 2,
-            page_id: pageId,
-            startingPageStateId,
-            startingPath: currentPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Goto,
-                        path: currentPath,
-                        playwrightCode: `await page.goto('${currentPath}')`,
-                        description: `Navigate to ${currentPath}`,
-                    },
-                    expectations: [
-                        {
-                            expectationType: ExpectationType.PageLoaded,
-                            severity: ExpectationSeverity.MustPass,
-                            description: `Page ${currentPath} should load`,
-                            playwrightCode: "await page.waitForLoadState('networkidle')",
-                        },
-                    ],
-                    description: `Navigate to ${currentPath}`,
-                    continueOnFailure: false,
-                },
-                {
-                    action: {
-                        actionType: PlaywrightAction.WaitForLoadState,
-                        playwrightCode: "await page.waitForLoadState('networkidle')",
-                        description: "Wait for page to settle",
-                    },
-                    expectations: [],
-                    description: "Wait for page to settle",
-                    continueOnFailure: true,
-                },
-                {
-                    action: {
-                        actionType: PlaywrightAction.Screenshot,
-                        value: `render-${this.slugify(currentPath)}`,
-                        playwrightCode: `await page.screenshot({ fullPage: true })`,
-                        description: "Capture screenshot",
-                    },
-                    expectations: [],
-                    description: "Capture screenshot",
-                    continueOnFailure: true,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Render page without runtime errors"),
-            uid,
-            generatedKey: this.buildGeneratedKey("render", startingPageStateId, pageId, currentPath),
-        };
-    }
-    buildFormTestInteraction(form, formLabel, formType, currentPath, sizeClass, uid, startingPageStateId, validValues) {
-        const steps = this.buildFormSteps(form, validValues, undefined);
-        return {
-            title: `Form — ${formLabel}`,
-            type: "form",
-            sizeClass,
-            surface_tags: ["form", formType],
-            priority: this.formPriority(formType),
-            startingPageStateId,
-            startingPath: currentPath,
-            steps,
-            globalExpectations: [
-                ...this.defaultFlowExpectations(`Form ${formLabel} should execute cleanly`),
-                ...(formType === "login" || formType === "signup"
-                    ? [
-                        this.makeExpectation(ExpectationType.NavigationOrStateChanged, `${formLabel} should advance authentication state after a successful submit`, {
-                            severity: ExpectationSeverity.ShouldPass,
-                        }),
-                        this.makeExpectation(ExpectationType.ErrorStateCleared, `${formLabel} should not leave a visible error state after a successful authentication submit`, {
-                            severity: ExpectationSeverity.ShouldPass,
-                        }),
-                    ]
-                    : []),
-                this.makeExpectation(ExpectationType.FormSubmittedSuccessfully, `Form ${formLabel} should submit without client-side errors`),
-                this.makeExpectation(ExpectationType.NetworkRequestMade, `Submitting ${formLabel} should trigger a backend mutation request`, {
-                    expectedValue: "mutation",
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, `Submitting ${formLabel} should not trigger duplicate mutation requests`),
-                this.makeExpectation("feedback_visible", `Submitting ${formLabel} should provide visible user feedback`, {
-                    expectedTextTokens: [
-                        "success",
-                        "saved",
-                        "submitted",
-                        "thank",
-                        "done",
-                    ],
-                    forbiddenTextTokens: ["error", "failed", "try again"],
-                }),
-                this.makeExpectation("feedback_not_duplicated", `Submitting ${formLabel} should not show duplicate feedback messages`),
-                this.makeExpectation("field_error_clears_after_fix", `Validation errors on ${formLabel} should clear once the fields are corrected`),
-            ],
-            uid,
-            generatedKey: this.buildGeneratedKey("form-positive", startingPageStateId, form.selector, formType),
-        };
-    }
-    buildNegativeFormTestInteraction(form, formLabel, formType, omittedField, currentPath, sizeClass, uid, startingPageStateId, validValues) {
-        const steps = this.buildFormSteps(form, validValues, omittedField.selector, this.buildValuePreservationExpectations(form, validValues, omittedField.selector));
-        return {
-            title: `Form Negative — ${formLabel} (missing ${this.fieldLabel(omittedField)})`,
-            type: "form_negative",
-            sizeClass,
-            surface_tags: ["form", "negative", formType],
-            priority: this.formPriority(formType) + 1,
-            startingPageStateId,
-            startingPath: currentPath,
-            steps,
-            globalExpectations: [
-                ...this.defaultFlowExpectations(`Negative form check for ${formLabel}`),
-                this.makeExpectation(ExpectationType.ValidationMessageVisible, `Validation feedback should appear when ${this.fieldLabel(omittedField)} is omitted`),
-                this.makeExpectation(ExpectationType.ErrorStateVisible, `Omitting ${this.fieldLabel(omittedField)} should surface an error state`),
-                this.makeExpectation("required_error_shown_for_field", `${this.fieldLabel(omittedField)} should show a required-field error when omitted`, {
-                    targetPath: omittedField.selector,
-                }),
-            ],
-            uid,
-            generatedKey: this.buildGeneratedKey("form-negative", startingPageStateId, form.selector, formType, omittedField.selector),
-        };
-    }
-    buildFormCorrectionTestInteraction(form, formLabel, formType, correctedField, currentPath, sizeClass, uid, startingPageStateId, validValues) {
-        const steps = this.buildFormSteps(form, validValues, correctedField.selector, this.buildValuePreservationExpectations(form, validValues, correctedField.selector));
-        const correctionValue = validValues[correctedField.selector];
-        if (correctionValue) {
-            const correctionStep = this.buildFieldStep(correctedField, correctionValue, this.makeExpectation("field_error_clears_after_fix", `${this.fieldLabel(correctedField)} should clear its validation error after correction`, {
-                targetPath: correctedField.selector,
-            }));
-            if (correctionStep) {
-                steps.push(correctionStep);
-            }
-        }
-        steps.push(...this.buildSubmitSteps(form.submitSelector));
-        return {
-            title: `Form Correction — ${formLabel} (fix ${this.fieldLabel(correctedField)})`,
-            type: "form",
-            sizeClass,
-            surface_tags: ["form", "correction", formType],
-            priority: this.formPriority(formType) + 1,
-            startingPageStateId,
-            startingPath: currentPath,
-            steps,
-            globalExpectations: [
-                ...this.defaultFlowExpectations(`Correction flow for ${formLabel}`),
-                this.makeExpectation(ExpectationType.ErrorStateCleared, `Error state for ${formLabel} should clear after correcting ${this.fieldLabel(correctedField)}`),
-                this.makeExpectation(ExpectationType.FormSubmittedSuccessfully, `Form ${formLabel} should submit after correcting ${this.fieldLabel(correctedField)}`),
-                this.makeExpectation(ExpectationType.NetworkRequestMade, `Submitting ${formLabel} after correction should trigger a backend mutation request`, {
-                    expectedValue: "mutation",
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, `Submitting ${formLabel} after correction should not trigger duplicate mutation requests`),
-                this.makeExpectation("feedback_visible", `Form ${formLabel} should show success feedback after correction`, {
-                    expectedTextTokens: [
-                        "success",
-                        "saved",
-                        "submitted",
-                        "thank",
-                        "done",
-                    ],
-                    forbiddenTextTokens: ["error", "required", "invalid"],
-                }),
-                this.makeExpectation("feedback_not_duplicated", `Form ${formLabel} should not show duplicate feedback after correction`),
-            ],
-            uid,
-            generatedKey: this.buildGeneratedKey("form-correction", startingPageStateId, form.selector, formType, correctedField.selector),
-        };
-    }
-    buildPasswordTestInteractions(form, formLabel, formType, currentPath, sizeClass, uid, startingPageStateId, validValues, passwordRequirements) {
-        const passwordFields = form.fields.filter(field => field.type === "password");
-        if (passwordFields.length === 0)
-            return [];
-        const variants = this.generatePasswordVariants(passwordRequirements);
-        return variants.map(variant => {
-            const values = { ...validValues };
-            for (const field of passwordFields) {
-                values[field.selector] = variant.password;
-            }
-            return {
-                title: `Password — ${formLabel} (${variant.description})`,
-                type: "password",
-                sizeClass,
-                surface_tags: ["form", "password", formType],
-                priority: variant.shouldFail ? 2 : 1,
-                startingPageStateId,
-                startingPath: currentPath,
-                steps: this.buildFormSteps(form, values, undefined),
-                globalExpectations: [
-                    ...this.defaultFlowExpectations(`Password flow ${variant.description}`),
-                    {
-                        expectationType: variant.shouldFail
-                            ? ExpectationType.ValidationMessageVisible
-                            : ExpectationType.FormSubmittedSuccessfully,
-                        severity: ExpectationSeverity.ShouldPass,
-                        description: variant.shouldFail
-                            ? `Password validation should reject ${variant.description}`
-                            : `Password validation should accept ${variant.description}`,
-                        playwrightCode: "// checked by password follow-up validation",
-                    },
-                ],
-                uid,
-                generatedKey: this.buildGeneratedKey("password", startingPageStateId, form.selector, formType, variant.description, variant.password),
-            };
-        });
-    }
-    buildE2ETestInteraction(currentPath, sizeClass, uid, startingPageStateId, journeySteps) {
-        return {
-            title: `E2E — Journey to ${currentPath}`,
-            type: "e2e",
-            sizeClass,
-            surface_tags: ["e2e"],
-            priority: 2,
-            startingPageStateId,
-            startingPath: currentPath,
-            steps: journeySteps.map(step => ({
-                ...step,
-                expectations: [],
-            })),
-            globalExpectations: this.defaultFlowExpectations(`Journey to ${currentPath} should complete without runtime errors`),
-            uid,
-            generatedKey: this.buildGeneratedKey("dependency-journey", startingPageStateId, currentPath, this.buildStepSignature(journeySteps)),
-        };
-    }
-    buildFormSteps(form, valuesBySelector, omittedSelector, postSubmitExpectations = []) {
-        const steps = [];
-        for (const field of form.fields) {
-            if (field.selector === omittedSelector)
-                continue;
-            const analyzerField = field;
-            const fieldIsImmutable = Boolean(analyzerField.disabled ||
-                analyzerField.readOnly ||
-                this.looksVisuallyDisabledField(analyzerField));
-            if (fieldIsImmutable)
-                continue;
-            const value = valuesBySelector[field.selector];
-            if (!value || this.isSkippableFieldType(field))
-                continue;
-            const step = this.buildFieldStep(field, value);
-            if (step)
-                steps.push(step);
-        }
-        steps.push(...this.buildSubmitSteps(form.submitSelector, postSubmitExpectations));
-        return steps;
-    }
-    buildFieldStep(field, value, trailingExpectation) {
-        const analyzerField = field;
-        const fieldIsImmutable = Boolean(analyzerField.disabled ||
-            analyzerField.readOnly ||
-            this.looksVisuallyDisabledField(analyzerField));
-        if (fieldIsImmutable)
-            return null;
-        if (this.isCheckboxLike(field)) {
-            return {
-                action: {
-                    actionType: PlaywrightAction.Check,
-                    path: field.selector,
-                    value,
-                    playwrightCode: `await page.locator('${field.selector}').check()`,
-                    description: `Check ${this.fieldLabel(field)}`,
-                },
-                expectations: [
-                    this.makeExpectation(ExpectationType.ElementChecked, `Checking ${this.fieldLabel(field)} should update the control state`, {
-                        targetPath: field.selector,
-                    }),
-                    ...(trailingExpectation ? [trailingExpectation] : []),
-                ],
-                description: `Check ${this.fieldLabel(field)}`,
-                continueOnFailure: false,
-            };
-        }
-        if (this.isSelectLike(field)) {
-            return {
-                action: {
-                    actionType: PlaywrightAction.SelectOption,
-                    path: field.selector,
-                    value,
-                    playwrightCode: `await page.locator('${field.selector}').selectOption('${value}')`,
-                    description: `Select ${this.fieldLabel(field)}`,
-                },
-                expectations: [
-                    this.makeExpectation(ExpectationType.InputValue, `Selecting ${this.fieldLabel(field)} should update the selected option`, {
-                        targetPath: field.selector,
-                        expectedValue: value,
-                    }),
-                    ...(trailingExpectation ? [trailingExpectation] : []),
-                ],
-                description: `Select ${this.fieldLabel(field)}`,
-                continueOnFailure: false,
-            };
-        }
-        return {
-            action: {
-                actionType: PlaywrightAction.Type,
-                path: field.selector,
-                value,
-                playwrightCode: `await page.locator('${field.selector}').type('${this.escapeSingleQuotes(value)}')`,
-                description: `Fill ${this.fieldLabel(field)}`,
-            },
-            expectations: [
-                this.makeExpectation(ExpectationType.InputValue, `Typing into ${this.fieldLabel(field)} should update the control value`, {
-                    targetPath: field.selector,
-                    expectedValue: value,
-                }),
-                ...(trailingExpectation ? [trailingExpectation] : []),
-            ],
-            description: `Fill ${this.fieldLabel(field)}`,
-            continueOnFailure: false,
-        };
-    }
-    buildSubmitSteps(submitSelector, postSubmitExpectations = []) {
-        if (!submitSelector)
-            return [];
-        return [
-            {
-                action: {
-                    actionType: PlaywrightAction.Click,
-                    path: submitSelector,
-                    playwrightCode: `await page.locator('${submitSelector}').click()`,
-                    description: "Submit form",
-                },
-                expectations: [],
-                description: "Submit form",
-                continueOnFailure: false,
-            },
-            {
-                action: {
-                    actionType: PlaywrightAction.WaitForLoadState,
-                    playwrightCode: "await page.waitForLoadState('networkidle')",
-                    description: "Wait for post-submit state",
-                },
-                expectations: postSubmitExpectations,
-                description: "Wait for post-submit state",
-                continueOnFailure: true,
-            },
-        ];
-    }
-    buildValuePreservationExpectations(form, valuesBySelector, omittedSelector) {
-        const expectations = [];
-        for (const field of form.fields) {
-            if (field.selector === omittedSelector)
-                continue;
-            const analyzerField = field;
-            const fieldIsImmutable = Boolean(analyzerField.disabled ||
-                analyzerField.readOnly ||
-                this.looksVisuallyDisabledField(analyzerField));
-            if (fieldIsImmutable)
-                continue;
-            const value = valuesBySelector[field.selector];
-            if (!value || this.isSkippableFieldType(field))
-                continue;
-            if (this.isCheckboxLike(field)) {
-                expectations.push(this.makeExpectation(ExpectationType.ElementChecked, `${this.fieldLabel(field)} should preserve its selected state after validation feedback`, {
-                    targetPath: field.selector,
-                }));
-                continue;
-            }
-            expectations.push(this.makeExpectation(ExpectationType.InputValue, `${this.fieldLabel(field)} should preserve its value after validation feedback`, {
-                targetPath: field.selector,
-                expectedValue: value,
-            }));
-        }
-        return expectations;
-    }
-    planFormValues(form, actionableItems) {
-        const values = {};
-        for (const field of form.fields) {
-            const analyzerField = field;
-            if (analyzerField.disabled ||
-                analyzerField.readOnly ||
-                this.looksVisuallyDisabledField(analyzerField)) {
-                continue;
-            }
-            if (this.isCheckboxLike(field)) {
-                values[field.selector] = "true";
-                continue;
-            }
-            if (this.isSelectLike(field)) {
-                const option = field.options?.find(value => value && value.trim().length > 0);
-                if (option)
-                    values[field.selector] = option;
-                continue;
-            }
-            const item = actionableItems.find(candidate => candidate.selector === field.selector);
-            const fallbackItem = item ?? {
-                stableKey: field.selector,
-                selector: field.selector,
-                tagName: field.type === "textarea" ? "TEXTAREA" : "INPUT",
-                inputType: field.type,
-                actionKind: "fill",
-                accessibleName: field.label,
-                disabled: false,
-                visible: true,
-                attributes: {
-                    name: field.name,
-                    placeholder: field.placeholder,
-                    labelText: field.label,
-                },
-            };
-            values[field.selector] = fillValuePlanner.planValue(fallbackItem);
-        }
-        return values;
-    }
-    identifyFormType(form, currentPath) {
-        const url = currentPath.toLowerCase();
-        const fields = form.fields;
-        const isLoginUrl = AUTH_URL_PATTERNS.some(pattern => url.includes(pattern));
-        const isSignupUrl = SIGNUP_URL_PATTERNS.some(pattern => url.includes(pattern));
-        const hasPassword = fields.some(field => field.type === "password");
-        const hasEmail = fields.some(field => {
-            const label = field.label.toLowerCase();
-            return (field.type === "email" ||
-                field.name.toLowerCase() === "email" ||
-                label.includes("email"));
-        });
-        const hasUsername = fields.some(field => {
-            const signal = `${field.name} ${field.label}`.toLowerCase();
-            return signal.includes("username") || signal.includes("user name");
-        });
-        const hasName = fields.some(field => {
-            const signal = `${field.name} ${field.label}`.toLowerCase();
-            return (signal.includes("name") &&
-                !signal.includes("username") &&
-                !signal.includes("email"));
-        });
-        const hasMessage = fields.some(field => {
-            const signal = `${field.name} ${field.label}`.toLowerCase();
-            return signal.includes("message") || signal.includes("subject");
-        });
-        const passwordCount = fields.filter(field => field.type === "password").length;
-        if (hasMessage)
-            return "other";
-        if (!hasPassword)
-            return "other";
-        if (hasEmail || hasUsername) {
-            if (passwordCount >= 2 || hasName || isSignupUrl)
-                return "signup";
-            if (isLoginUrl)
-                return "login";
-            if (fields.length <= 2)
-                return "login";
-            return hasName ? "signup" : "login";
-        }
-        if (isSignupUrl)
-            return "signup";
-        if (isLoginUrl)
-            return "login";
-        return "other";
-    }
-    isSearchForm(form) {
-        if (String(form.method || "").toUpperCase() === "GET") {
-            return true;
-        }
-        return form.fields.some(field => this.isSearchField(field));
-    }
-    isSearchField(field) {
-        const text = [
-            field.type,
-            field.label,
-            field.name,
-            field.placeholder,
-            field.selector,
-        ]
-            .filter(Boolean)
-            .join(" ")
-            .toLowerCase();
-        return field.type === "search" || /\bsearch\b/.test(text);
-    }
-    buildSearchTestInteractions(form, formLabel, currentPath, sizeClass, uid, startingPageStateId, validValues, actionableItems) {
-        const searchField = form.fields.find(field => this.isSearchField(field));
-        if (!searchField)
-            return [];
-        const searchValues = {
-            ...validValues,
-            [searchField.selector]: "test",
-        };
-        const noResultsValues = {
-            ...validValues,
-            [searchField.selector]: this.improbableSearchQuery(),
-        };
-        const tests = [
-            {
-                title: `Search — ${formLabel}`,
-                type: "form",
-                sizeClass,
-                surface_tags: ["form", "search"],
-                priority: 2,
-                startingPageStateId,
-                startingPath: currentPath,
-                steps: this.buildFormSteps(form, searchValues, undefined),
-                globalExpectations: [
-                    ...this.defaultFlowExpectations(`Search flow ${formLabel}`),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, `Searching via ${formLabel} should issue a GET request`, {
-                        expectedValue: "GET",
-                        timeoutMs: 3000,
-                        expectedTextTokens: ["search", "q=", "query", "term"],
-                    }),
-                    this.makeExpectation(ExpectationType.NavigationOrStateChanged, `Searching via ${formLabel} should change the page or result state`),
-                    this.makeExpectation(ExpectationType.ResultsChanged, `Searching via ${formLabel} should change the visible results`),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, `Search results for ${formLabel} should finish loading`),
-                ],
-                uid,
-                generatedKey: this.buildGeneratedKey("search", startingPageStateId, form.selector, searchField.selector),
-            },
-            {
-                title: `Search Empty State — ${formLabel}`,
-                type: "form",
-                sizeClass,
-                surface_tags: ["form", "search", "empty-state"],
-                priority: 3,
-                startingPageStateId,
-                startingPath: currentPath,
-                steps: this.buildFormSteps(form, noResultsValues, undefined),
-                globalExpectations: [
-                    ...this.defaultFlowExpectations(`Empty-state search flow ${formLabel}`),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, `No-result search via ${formLabel} should still issue a GET request`, {
-                        expectedValue: "GET",
-                        timeoutMs: 3000,
-                        expectedTextTokens: ["search", "q=", "query", "term"],
-                    }),
-                    this.makeExpectation(ExpectationType.NavigationOrStateChanged, `No-result search via ${formLabel} should change the page or result state`),
-                    this.makeExpectation(ExpectationType.EmptyStateVisible, `No-result search via ${formLabel} should show an empty state`),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, `No-result search for ${formLabel} should finish loading`),
-                ],
-                uid,
-                generatedKey: this.buildGeneratedKey("search-empty", startingPageStateId, form.selector, searchField.selector),
-            },
-            {
-                title: `Search Recovery — ${formLabel}`,
-                type: "form",
-                sizeClass,
-                surface_tags: ["form", "search", "recovery"],
-                priority: 3,
-                startingPageStateId,
-                startingPath: currentPath,
-                steps: [
-                    ...this.buildFormSteps(form, noResultsValues, undefined),
-                    ...this.buildSearchRecoverySteps(form, searchField, "test"),
-                ],
-                globalExpectations: [
-                    ...this.defaultFlowExpectations(`Search recovery flow ${formLabel}`),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, `Recovering search results via ${formLabel} should issue GET requests`, {
-                        expectedValue: "GET",
-                        timeoutMs: 3000,
-                        expectedTextTokens: ["search", "q=", "query", "term"],
-                    }),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, `Search recovery for ${formLabel} should finish loading`),
-                ],
-                uid,
-                generatedKey: this.buildGeneratedKey("search-recovery", startingPageStateId, form.selector, searchField.selector),
-            },
-        ];
-        const clearAction = actionableItems.find(item => this.isSearchClearItem(item));
-        if (clearAction) {
-            const clearSteps = this.buildFormSteps(form, searchValues, undefined);
-            clearSteps.push(this.buildJourneyAction(clearAction, "Clear search", [
-                this.makeExpectation(ExpectationType.ResultsRestored, `Clearing ${formLabel} should restore the baseline results`),
-                this.makeExpectation(ExpectationType.InputValue, `Clearing ${formLabel} should empty the search field`, {
-                    targetPath: searchField.selector,
-                    expectedValue: "",
-                }),
-            ]));
-            tests.push({
-                title: `Search Clear Restore — ${formLabel}`,
-                type: "form",
-                sizeClass,
-                surface_tags: ["form", "search", "restore"],
-                priority: 3,
-                startingPageStateId,
-                startingPath: currentPath,
-                steps: clearSteps,
-                globalExpectations: [
-                    ...this.defaultFlowExpectations(`Search clear flow ${formLabel}`),
-                    this.makeExpectation(ExpectationType.ResultsRestored, `Clearing ${formLabel} should restore the initial results baseline`),
-                ],
-                uid,
-                generatedKey: this.buildGeneratedKey("search-clear", startingPageStateId, form.selector, searchField.selector, clearAction.selector),
-            });
-        }
-        return tests;
-    }
-    buildSearchRecoverySteps(form, searchField, recoveryValue) {
-        const steps = [];
-        const refillStep = this.buildFieldStep(searchField, recoveryValue);
-        if (refillStep) {
-            steps.push(refillStep);
-        }
-        steps.push(...this.buildSubmitSteps(form.submitSelector, [
-            this.makeExpectation(ExpectationType.ResultsChanged, `${this.fieldLabel(searchField)} should recover from the empty state to a different result set`),
-            this.makeExpectation(ExpectationType.InputValue, `${this.fieldLabel(searchField)} should preserve the recovery query after resubmission`, {
-                targetPath: searchField.selector,
-                expectedValue: recoveryValue,
-            }),
-            this.makeExpectation(ExpectationType.LoadingCompletes, "Recovered search results should finish loading"),
-        ]));
-        return steps;
-    }
-    describeForm(form, index) {
-        const namedField = form.fields.find(field => field.label || field.name);
-        const descriptor = namedField?.label || namedField?.name || `form ${index + 1}`;
-        return `${descriptor} @ ${form.selector}`;
-    }
-    buildSemanticJourneyTestInteractions(context) {
-        const items = this.selectRepresentativeItems(context.actionableItems.filter(item => item.visible && !item.disabled && Boolean(item.selector)));
-        const journeys = [];
-        const collectionCount = this.estimateCollectionCount(context.html);
-        const addToCart = items.find(item => this.isAddToCartItem(item));
-        const checkout = items.find(item => this.isCheckoutItem(item));
-        const createCollectionAction = items.find(item => this.isCreateCollectionAction(item));
-        if (addToCart && checkout) {
-            journeys.push(this.buildJourneyTestInteraction("Commerce journey", ["commerce", "cart", "checkout"], context, [
-                this.buildJourneyAction(addToCart, "Add item to cart", [
-                    this.makeExpectation("navigation_or_state_changed", "Adding an item to cart should update the page state"),
-                    this.makeExpectation("count_changed", "Adding an item should update a visible count", {
-                        expectedCountDelta: 1,
-                    }),
-                    this.makeExpectation("cart_summary_changed", "Adding an item should update the cart summary"),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, "Adding an item should trigger a backend mutation request", {
-                        expectedValue: "mutation",
-                        timeoutMs: 3000,
-                    }),
-                    this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, "Adding an item should not trigger duplicate mutation requests"),
-                    this.makeExpectation("feedback_visible", "Adding an item should provide visible feedback", {
-                        expectedTextTokens: ["added", "success", "cart", "bag"],
-                        forbiddenTextTokens: ["error", "failed"],
-                    }),
-                    this.makeExpectation("feedback_not_duplicated", "Adding an item should not show duplicate feedback messages"),
-                    this.makeExpectation("loading_completes", "Cart update should complete loading"),
-                    this.makeExpectation("page_responsive", "Page should remain responsive after cart update"),
-                ]),
-                this.waitStep(700, "Wait for cart state"),
-                this.buildJourneyAction(checkout, "Proceed to checkout", [
-                    this.makeExpectation("navigation_or_state_changed", "Proceeding to checkout should change the page state"),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, "Proceeding to checkout should trigger a network request or document transition", {
-                        expectedValue: "ANY",
-                        timeoutMs: 3000,
-                        expectedTextTokens: ["checkout"],
-                    }),
-                    this.makeExpectation("loading_completes", "Checkout transition should complete loading"),
-                    this.makeExpectation("page_responsive", "Page should remain responsive during checkout transition"),
-                ]),
-            ]));
-        }
-        const removeItem = items.find(item => this.isRemoveItemAction(item));
-        if (removeItem) {
-            const removeExpectations = [
-                this.makeExpectation("navigation_or_state_changed", "Removing an item should change the page state"),
-                this.makeExpectation("count_changed", "Removing an item should update a visible count", {
-                    expectedCountDelta: -1,
-                }),
-                this.makeExpectation("cart_summary_changed", "Removing an item should update the cart summary"),
-                this.makeExpectation("row_count_changed", "Removing an item should change the visible row or item count", {
-                    expectedCountDelta: -1,
-                }),
-                this.makeExpectation("results_changed", "Removing an item should change the visible collection state"),
-                this.makeExpectation(ExpectationType.NetworkRequestMade, "Removing an item should trigger a backend mutation request", {
-                    expectedValue: "mutation",
-                    timeoutMs: 3000,
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, "Removing an item should not trigger duplicate mutation requests"),
-                this.makeExpectation("feedback_visible", "Removing an item should provide visible feedback", {
-                    expectedTextTokens: ["removed", "updated", "cart", "bag"],
-                    forbiddenTextTokens: ["error", "failed"],
-                }),
-                this.makeExpectation("feedback_not_duplicated", "Removing an item should not show duplicate feedback messages"),
-                this.makeExpectation("loading_completes", "Removal flow should complete loading"),
-                this.makeExpectation("page_responsive", "Page should remain responsive after removal"),
-            ];
-            if (this.estimateCollectionCount(context.html) <= 1) {
-                removeExpectations.push(this.makeExpectation(ExpectationType.EmptyStateVisible, "Removing the last visible item should show an empty state or zero-results message", {
-                    expectedTextTokens: [
-                        "no items",
-                        "no products",
-                        "empty",
-                        "no results",
-                        "nothing found",
-                    ],
-                    severity: ExpectationSeverity.ShouldPass,
-                }));
-            }
-            journeys.push(this.buildJourneyTestInteraction("Remove item from collection", ["commerce", "remove"], context, [
-                this.buildJourneyAction(removeItem, "Remove item", removeExpectations),
-            ]));
-        }
-        if (createCollectionAction) {
-            const createExpectations = [
-                this.makeExpectation("navigation_or_state_changed", "Creating or adding a record should change the page state"),
-                this.makeExpectation("row_count_changed", "Creating or adding a record should increase the visible row or item count", {
-                    expectedCountDelta: 1,
-                }),
-                this.makeExpectation("results_changed", "Creating or adding a record should change the visible collection state"),
-                this.makeExpectation(ExpectationType.NetworkRequestMade, "Creating or adding a record should trigger a backend mutation request", {
-                    expectedValue: "mutation",
-                    timeoutMs: 3000,
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, "Creating or adding a record should not trigger duplicate mutation requests"),
-                this.makeExpectation("feedback_not_duplicated", "Creating or adding a record should not duplicate visible feedback"),
-                this.makeExpectation("loading_completes", "Create/add flow should complete loading"),
-                this.makeExpectation("page_responsive", "Page should remain responsive after creating or adding a record"),
-            ];
-            journeys.push(this.buildJourneyTestInteraction("Create or add collection record", ["list", "crud", "create"], context, [
-                this.buildJourneyAction(createCollectionAction, "Create or add record", createExpectations),
-            ]));
-        }
-        const authEntry = items.find(item => this.isAuthEntryItem(item));
-        if (authEntry) {
-            journeys.push(this.buildJourneyTestInteraction("Authentication entry journey", ["auth"], context, [
-                this.buildJourneyAction(authEntry, "Open authentication entry point", [
-                    this.makeExpectation("navigation_or_state_changed", "Authentication entry should open the next auth state"),
-                    this.makeExpectation("loading_completes", "Authentication entry flow should settle"),
-                    this.makeExpectation("page_responsive", "Page should remain responsive when opening auth flow"),
-                ]),
-            ]));
-        }
-        const protectedAction = items.find(item => item !== authEntry && this.isProtectedActionItem(item));
-        if (authEntry && protectedAction) {
-            journeys.push(this.buildJourneyTestInteraction("Protected action auth gate journey", ["auth", "protected"], context, [
-                this.buildJourneyAction(protectedAction, "Open protected action", [
-                    this.makeExpectation(ExpectationType.NavigationOrStateChanged, "Protected action should open a gated state, redirect, or login requirement"),
-                    this.makeExpectation(ExpectationType.PageResponsive, "Page should remain responsive when auth gating is triggered"),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, "Protected action gate should settle cleanly"),
-                ]),
-            ]));
-        }
-        const logoutAction = items.find(item => this.isLogoutAction(item));
-        if (logoutAction) {
-            journeys.push(this.buildJourneyTestInteraction("Logout journey", ["auth", "logout"], context, [
-                this.buildJourneyAction(logoutAction, "Log out", [
-                    this.makeExpectation(ExpectationType.NavigationOrStateChanged, "Logging out should change application state"),
-                    this.makeExpectation(ExpectationType.PageResponsive, "Page should remain responsive during logout"),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, "Logout should settle cleanly"),
-                    this.makeExpectation(ExpectationType.FeedbackVisible, "Logout should provide visible confirmation or a clear state change", {
-                        forbiddenTextTokens: ["error", "failed"],
-                    }),
-                    this.makeExpectation(ExpectationType.ErrorStateCleared, "Logout should not leave visible recoverable error state behind", {
-                        severity: ExpectationSeverity.ShouldPass,
-                    }),
-                ]),
-            ]));
-        }
-        const retryAction = items.find(item => this.isRetryAction(item));
-        if (retryAction) {
-            journeys.push(this.buildJourneyTestInteraction("Retry recovery journey", ["recovery", "retry"], context, [
-                this.buildJourneyAction(retryAction, "Retry failed action", [
-                    this.makeExpectation(ExpectationType.ErrorStateCleared, "Retrying should clear any visible recoverable error state"),
-                    this.makeExpectation(ExpectationType.NetworkRequestMade, "Retrying should trigger a follow-up request or state transition", {
-                        expectedValue: "ANY",
-                        timeoutMs: 3000,
-                    }),
-                    this.makeExpectation("navigation_or_state_changed", "Retrying should change page state or visibly advance recovery"),
-                    this.makeExpectation("loading_completes", "Retry recovery should complete loading"),
-                    this.makeExpectation("page_responsive", "Page should remain responsive during retry recovery"),
-                    this.makeExpectation("feedback_not_duplicated", "Retry recovery should not duplicate visible feedback"),
-                    this.makeExpectation("feedback_visible", "Retry recovery should show updated feedback or state confirmation", {
-                        forbiddenTextTokens: ["error", "failed", "try again"],
-                    }),
-                ]),
-            ]));
-        }
-        const mediaCandidate = items.find(item => this.isMediaOpenItem(item));
-        if (mediaCandidate) {
-            const mediaExpectations = [
-                this.makeExpectation("modal_opened", "Opening media should reveal a modal, overlay, or new state"),
-                this.makeExpectation("media_loaded", "Opened media should load successfully"),
-            ];
-            if (this.isVideoLikeItem(mediaCandidate)) {
-                mediaExpectations.push(this.makeExpectation("video_playable", "Opened video should be playable"));
-            }
-            journeys.push(this.buildJourneyTestInteraction("Media open journey", ["media"], context, [
-                this.buildJourneyAction(mediaCandidate, "Open media", mediaExpectations),
-            ]));
-        }
-        for (const quantityAction of items.filter(item => this.isQuantityAction(item))) {
-            const quantityDelta = this.inferQuantityDelta(quantityAction);
-            const quantityExpectations = [
-                this.makeExpectation("count_changed", "Adjusting quantity should update a visible count or quantity indicator", quantityDelta == null
-                    ? undefined
-                    : { expectedCountDelta: quantityDelta }),
-                this.makeExpectation("cart_summary_changed", "Adjusting quantity should update subtotal, totals, or line pricing"),
-                this.makeExpectation("results_changed", "Adjusting quantity should change the visible cart or line-item state"),
-                this.makeExpectation(ExpectationType.NetworkRequestMade, "Adjusting quantity should trigger a backend mutation request", {
-                    expectedValue: "mutation",
-                    timeoutMs: 3000,
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, "Adjusting quantity should not trigger duplicate mutation requests"),
-                this.makeExpectation("feedback_not_duplicated", "Quantity adjustment should not duplicate visible feedback"),
-                this.makeExpectation("loading_completes", "Quantity adjustment should complete loading"),
-                this.makeExpectation("page_responsive", "Page should remain responsive during quantity adjustment"),
-            ].filter(Boolean);
-            journeys.push(this.buildJourneyTestInteraction(quantityDelta === -1
-                ? "Quantity decrease journey"
-                : quantityDelta === 1
-                    ? "Quantity increase journey"
-                    : "Quantity adjustment journey", ["commerce", "quantity"], context, [
-                this.buildJourneyAction(quantityAction, quantityDelta === -1
-                    ? "Decrease quantity"
-                    : quantityDelta === 1
-                        ? "Increase quantity"
-                        : "Adjust quantity", quantityExpectations),
-            ]));
-        }
-        const filterAction = items.find(item => this.isFilterAction(item));
-        if (filterAction) {
-            journeys.push(this.buildJourneyTestInteraction("Filter results journey", ["filter"], context, [
-                this.buildJourneyAction(filterAction, "Apply filter", [
-                    this.makeExpectation("navigation_or_state_changed", "Applying a filter should change the result state"),
-                    this.makeExpectation("results_changed", "Applying a filter should change the visible result summary"),
-                    this.makeExpectation("loading_completes", "Filter update should complete loading"),
-                ]),
-            ]));
-            journeys.push(this.buildJourneyTestInteraction("Filter persistence journey", ["filter", "reload"], context, [
-                this.buildJourneyAction(filterAction, "Apply filter", [
-                    this.makeExpectation("navigation_or_state_changed", "Applying a filter should change the result state"),
-                ]),
-                this.waitStep(500, "Wait for filtered state"),
-                this.buildReloadStep([
-                    this.makeExpectation("state_persists_after_reload", "Filter state should persist after reload", {
-                        expectedTextTokens: ["filter", "results", "showing", "items"],
-                    }),
-                ]),
-            ]));
-        }
-        const sortAction = items.find(item => this.isSortAction(item));
-        if (sortAction) {
-            journeys.push(this.buildJourneyTestInteraction("Sort results journey", ["sort"], context, [
-                this.buildJourneyAction(sortAction, "Change sort order", [
-                    this.makeExpectation("navigation_or_state_changed", "Changing sort should update the result state"),
-                    this.makeExpectation("collection_order_changed", "Changing sort should change the visible collection ordering"),
-                    this.makeExpectation("loading_completes", "Sort update should complete loading"),
-                ]),
-            ]));
-        }
-        const paginationAction = items.find(item => this.isPaginationAction(item));
-        if (paginationAction) {
-            journeys.push(this.buildJourneyTestInteraction("Pagination journey", ["list", "pagination"], context, [
-                this.buildJourneyAction(paginationAction, "Paginate list", [
-                    this.makeExpectation(ExpectationType.NavigationOrStateChanged, "Pagination should change the visible list state"),
-                    this.makeExpectation("results_changed", "Pagination should change the visible collection contents"),
-                    this.makeExpectation("row_count_changed", "Pagination should change the visible rows or items"),
-                    this.makeExpectation("collection_order_changed", "Pagination should change the visible collection ordering or composition"),
-                    this.makeExpectation(ExpectationType.LoadingCompletes, "Pagination should complete loading"),
-                ]),
-            ]));
-        }
-        if (addToCart) {
-            journeys.push(this.buildJourneyTestInteraction("Cart persistence journey", ["commerce", "reload"], context, [
-                this.buildJourneyAction(addToCart, "Add item to cart", [
-                    this.makeExpectation("navigation_or_state_changed", "Adding an item should change page state before reload"),
-                ]),
-                this.waitStep(500, "Wait for updated cart state"),
-                this.buildReloadStep([
-                    this.makeExpectation("state_persists_after_reload", "Cart state should persist after reload", {
-                        expectedTextTokens: [
-                            "cart",
-                            "bag",
-                            "basket",
-                            "qty",
-                            "quantity",
-                        ],
-                    }),
-                ]),
-            ]));
-        }
-        if (collectionCount > 0 && removeItem && createCollectionAction) {
-            journeys.push(this.buildJourneyTestInteraction("Collection mutation recovery journey", ["list", "crud", "recovery"], context, [
-                this.buildJourneyAction(removeItem, "Remove record", [
-                    this.makeExpectation("row_count_changed", "Removing a record should change the visible collection", {
-                        expectedCountDelta: -1,
-                    }),
-                    this.makeExpectation("results_changed", "Removing a record should change the visible collection contents"),
-                ]),
-                this.waitStep(500, "Wait for collection mutation"),
-                this.buildJourneyAction(createCollectionAction, "Add record back", [
-                    this.makeExpectation("row_count_changed", "Adding a record back should restore visible collection size", {
-                        expectedCountDelta: 1,
-                    }),
-                    this.makeExpectation("results_changed", "Adding a record back should change the visible collection contents again"),
-                    this.makeExpectation("loading_completes", "Collection recovery should complete loading"),
-                ]),
-            ]));
-        }
-        const backCandidate = items.find(item => item.actionKind === "navigate" ||
-            this.isMediaOpenItem(item) ||
-            this.isAuthEntryItem(item));
-        if (backCandidate) {
-            journeys.push(this.buildJourneyTestInteraction("Back and forward navigation journey", ["navigation", "history"], context, [
-                this.buildJourneyAction(backCandidate, "Navigate to next state", [
-                    this.makeExpectation("navigation_or_state_changed", "Navigation should move to a different state"),
-                ]),
-                this.waitStep(500, "Wait for next state"),
-                this.buildBackStep([
-                    this.makeExpectation("back_navigation_restores_state", "Back navigation should restore the previous state"),
-                ]),
-                this.waitStep(300, "Wait after back navigation"),
-                this.buildForwardStep([
-                    this.makeExpectation("forward_navigation_reapplies_state", "Forward navigation should reapply the later state"),
-                ]),
-            ]));
-        }
-        return journeys;
-    }
-    buildJourneyTestInteraction(title, surfaceTags, context, steps) {
-        return {
-            title: `${title} — ${context.currentPath}`,
-            type: "e2e",
-            sizeClass: context.sizeClass,
-            surface_tags: ["e2e", ...surfaceTags],
-            priority: 2,
-            startingPageStateId: context.currentPageStateId,
-            startingPath: context.currentPath,
-            steps,
-            globalExpectations: this.defaultFlowExpectations(`${title} should complete without runtime errors`),
-            uid: context.uid,
-            generatedKey: this.buildGeneratedKey("semantic-journey", context.currentPageStateId, context.currentPath, this.buildStepSignature(steps)),
-        };
-    }
-    buildJourneyAction(item, description, expectations) {
-        const signal = this.describeActionableItem(item);
-        const action = this.buildSemanticAction(item, description, signal);
-        return {
-            action,
-            expectations,
-            description: `${description}: ${signal}`,
-            continueOnFailure: false,
-        };
-    }
-    waitStep(ms, description) {
-        return {
-            action: {
-                actionType: PlaywrightAction.WaitForTimeout,
-                value: String(ms),
-                playwrightCode: `await page.waitForTimeout(${ms})`,
-                description,
-            },
-            expectations: [],
-            description,
-            continueOnFailure: true,
-        };
-    }
-    buildReloadStep(expectations) {
-        return {
-            action: {
-                actionType: PlaywrightAction.Reload,
-                playwrightCode: "await page.reload({ waitUntil: 'networkidle' })",
-                description: "Reload page",
-            },
-            expectations,
-            description: "Reload page",
-            continueOnFailure: false,
-        };
-    }
-    buildBackStep(expectations) {
-        return {
-            action: {
-                actionType: PlaywrightAction.GoBack,
-                playwrightCode: "await page.goBack()",
-                description: "Go back",
-            },
-            expectations,
-            description: "Go back",
-            continueOnFailure: false,
-        };
-    }
-    buildForwardStep(expectations) {
-        return {
-            action: {
-                actionType: PlaywrightAction.GoForward,
-                playwrightCode: "await page.goForward()",
-                description: "Go forward",
-            },
-            expectations,
-            description: "Go forward",
-            continueOnFailure: false,
-        };
-    }
-    defaultFlowExpectations(description) {
-        return [
-            {
-                expectationType: ExpectationType.PageLoaded,
-                severity: ExpectationSeverity.MustPass,
-                description,
-                playwrightCode: "await page.waitForLoadState('networkidle')",
-            },
-            {
-                expectationType: ExpectationType.NoNetworkErrors,
-                severity: ExpectationSeverity.ShouldPass,
-                description: "No network errors during flow",
-                playwrightCode: "// checked by TesterExpertise",
-            },
-            {
-                expectationType: ExpectationType.NoConsoleErrors,
-                severity: ExpectationSeverity.ShouldPass,
-                description: "No console errors during flow",
-                playwrightCode: "// checked by TesterExpertise",
-            },
-        ];
-    }
-    formPriority(formType) {
-        if (formType === "login" || formType === "signup")
-            return 1;
-        return 2;
-    }
-    isNegativeCandidateField(field) {
-        const analyzerField = field;
-        return (field.required &&
-            !analyzerField.disabled &&
-            !analyzerField.readOnly &&
-            !this.looksVisuallyDisabledField(analyzerField) &&
-            !this.isCheckboxLike(field) &&
-            !this.isSkippableFieldType(field));
-    }
-    isPasswordScenario(formType, form) {
-        return (formType !== "other" &&
-            form.fields.some(field => field.type === "password"));
-    }
-    isCheckboxLike(field) {
-        return field.type === "checkbox" || field.type === "radio";
-    }
-    buildKeyboardAndDisclosureTestInteractions(context) {
-        const items = this.selectRepresentativeItems(context.actionableItems.filter(item => item.visible && !item.disabled && Boolean(item.selector)));
-        const tests = [];
-        for (const item of items) {
-            if (this.isDisclosureItem(item)) {
-                tests.push(this.buildDisclosureToggleTestInteraction(item, context.currentPath, context.sizeClass, context.uid, context.currentPageStateId));
-                tests.push(this.buildKeyboardActivateTestInteraction(item, "Enter", "Activate disclosure with Enter", [
-                    this.makeExpectation("expanded_state_changed", "Enter should toggle the disclosure state", {
-                        targetPath: item.selector,
-                    }),
-                ], context.currentPath, context.sizeClass, context.uid, context.currentPageStateId));
-                tests.push(this.buildKeyboardActivateTestInteraction(item, " ", "Activate disclosure with Space", [
-                    this.makeExpectation("expanded_state_changed", "Space should toggle the disclosure state", {
-                        targetPath: item.selector,
-                    }),
-                ], context.currentPath, context.sizeClass, context.uid, context.currentPageStateId));
-                continue;
-            }
-            if (this.isKeyboardPrimaryAction(item)) {
-                tests.push(this.buildKeyboardActivateTestInteraction(item, "Enter", "Activate with Enter", [
-                    this.makeExpectation("navigation_or_state_changed", "Enter key activation should change the page or control state"),
-                ], context.currentPath, context.sizeClass, context.uid, context.currentPageStateId));
-            }
-            if (this.isKeyboardToggleAction(item)) {
-                tests.push(this.buildKeyboardActivateTestInteraction(item, " ", "Toggle with Space", [
-                    this.makeExpectation(ExpectationType.ElementChecked, "Space key activation should toggle the control state", {
-                        targetPath: item.selector,
-                    }),
-                ], context.currentPath, context.sizeClass, context.uid, context.currentPageStateId));
-            }
-        }
-        return tests;
-    }
-    buildVariantTestInteractions(context) {
-        const items = this.selectRepresentativeItems(context.actionableItems.filter(item => item.visible &&
-            !item.disabled &&
-            Boolean(item.selector) &&
-            this.isVariantSelector(item)));
-        const tests = items
-            .map(item => this.buildVariantTestInteraction(item, context))
-            .filter((item) => Boolean(item));
-        const purchaseAction = context.actionableItems.find(item => item.visible &&
-            !item.disabled &&
-            Boolean(item.selector) &&
-            (this.isAddToCartItem(item) || this.isCheckoutItem(item)));
-        for (const item of items) {
-            const purchaseJourney = this.buildVariantPurchaseJourney(item, purchaseAction, context);
-            if (purchaseJourney)
-                tests.push(purchaseJourney);
-            const requiredField = this.findRequiredVariantField(item, context.forms);
-            if (requiredField && purchaseAction) {
-                tests.push(this.buildRequiredVariantGuardTestInteraction(item, requiredField, purchaseAction, context));
-            }
-        }
-        return tests;
-    }
-    buildVariantTestInteraction(item, context) {
-        const plannedValue = this.extractSelectableValue(item);
-        if (!plannedValue || !item.selector)
-            return null;
-        const label = this.describeActionableItem(item);
-        return {
-            title: `Variant selection ${label}`,
-            type: "interaction",
-            sizeClass: context.sizeClass,
-            surface_tags: ["variant", "selection"],
-            priority: 2,
-            startingPageStateId: context.currentPageStateId,
-            startingPath: context.currentPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.SelectOption,
-                        path: item.selector,
-                        value: plannedValue,
-                        playwrightCode: `await page.locator('${item.selector}').selectOption('${this.escapeSingleQuotes(plannedValue)}')`,
-                        description: `Select variant ${label}`,
-                    },
-                    expectations: [
-                        this.makeExpectation(ExpectationType.InputValue, `Selecting ${label} should update the chosen variant option`, {
-                            targetPath: item.selector,
-                            expectedValue: plannedValue,
-                        }),
-                        this.makeExpectation(ExpectationType.VariantStateChanged, `Selecting ${label} should change product state`, {
-                            targetPath: item.selector,
-                            expectedValue: plannedValue,
-                        }),
-                    ],
-                    description: `Select variant ${label}`,
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Variant selection should complete without runtime errors"),
-            uid: context.uid,
-            generatedKey: this.buildGeneratedKey("variant-selection", context.currentPageStateId, item.selector, plannedValue),
-        };
-    }
-    buildVariantPurchaseJourney(item, purchaseAction, context) {
-        const plannedValue = this.extractSelectableValue(item);
-        if (!plannedValue || !item.selector || !purchaseAction?.selector) {
-            return null;
-        }
-        const label = this.describeActionableItem(item);
-        const purchaseLabel = this.describeActionableItem(purchaseAction);
-        const purchaseExpectations = this.isAddToCartItem(purchaseAction)
-            ? [
-                this.makeExpectation(ExpectationType.NetworkRequestMade, `${purchaseLabel} should trigger a backend mutation request after selecting ${label}`, {
-                    expectedValue: "mutation",
-                    timeoutMs: 3000,
-                }),
-                this.makeExpectation(ExpectationType.NoDuplicateMutationRequests, `${purchaseLabel} should not trigger duplicate mutation requests after selecting ${label}`),
-                this.makeExpectation(ExpectationType.CountChanged, `${purchaseLabel} should update a visible count after selecting ${label}`, {
-                    expectedCountDelta: 1,
-                }),
-                this.makeExpectation(ExpectationType.CartSummaryChanged, `${purchaseLabel} should update cart summary after selecting ${label}`),
-                this.makeExpectation(ExpectationType.FeedbackVisible, `${purchaseLabel} should provide visible feedback after selecting ${label}`, {
-                    expectedTextTokens: ["added", "success", "cart", "bag"],
-                    forbiddenTextTokens: ["error", "failed"],
-                }),
-            ]
-            : [
-                this.makeExpectation(ExpectationType.NetworkRequestMade, `${purchaseLabel} should trigger a request or transition after selecting ${label}`, {
-                    expectedValue: "ANY",
-                    timeoutMs: 3000,
-                    expectedTextTokens: ["checkout", "buy", "order"],
-                }),
-                this.makeExpectation(ExpectationType.NavigationOrStateChanged, `${purchaseLabel} should advance the purchase flow after selecting ${label}`),
-            ];
-        return {
-            title: `Variant purchase journey ${label}`,
-            type: "interaction",
-            sizeClass: context.sizeClass,
-            surface_tags: ["variant", "purchase"],
-            priority: 2,
-            startingPageStateId: context.currentPageStateId,
-            startingPath: context.currentPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.SelectOption,
-                        path: item.selector,
-                        value: plannedValue,
-                        playwrightCode: `await page.locator('${item.selector}').selectOption('${this.escapeSingleQuotes(plannedValue)}')`,
-                        description: `Select variant ${label}`,
-                    },
-                    expectations: [
-                        this.makeExpectation(ExpectationType.InputValue, `Selecting ${label} should update the chosen option`, {
-                            targetPath: item.selector,
-                            expectedValue: plannedValue,
-                        }),
-                        this.makeExpectation(ExpectationType.VariantStateChanged, `Selecting ${label} should update product state before purchase`, {
-                            targetPath: item.selector,
-                            expectedValue: plannedValue,
-                        }),
-                    ],
-                    description: `Select variant ${label}`,
-                    continueOnFailure: false,
-                },
-                this.buildJourneyAction(purchaseAction, `Purchase with selected ${label}`, [
-                    ...purchaseExpectations,
-                    this.makeExpectation(ExpectationType.LoadingCompletes, `${purchaseLabel} should complete loading after selecting ${label}`),
-                    this.makeExpectation(ExpectationType.PageResponsive, `Page should remain responsive while completing ${purchaseLabel}`),
-                ]),
-            ],
-            globalExpectations: this.defaultFlowExpectations(`Variant purchase journey for ${label} should execute cleanly`),
-            uid: context.uid,
-            generatedKey: this.buildGeneratedKey("variant-purchase", context.currentPageStateId, item.selector, plannedValue, purchaseAction.selector),
-        };
-    }
-    buildRequiredVariantGuardTestInteraction(item, requiredField, purchaseAction, context) {
-        const label = this.describeActionableItem(item);
-        const purchaseLabel = this.describeActionableItem(purchaseAction);
-        return {
-            title: `Variant required guard ${label}`,
-            type: "interaction",
-            sizeClass: context.sizeClass,
-            surface_tags: ["variant", "validation", "guard"],
-            priority: 3,
-            startingPageStateId: context.currentPageStateId,
-            startingPath: context.currentPath,
-            steps: [
-                this.buildJourneyAction(purchaseAction, `Attempt ${purchaseLabel} without selecting ${label}`, [
-                    this.makeExpectation(ExpectationType.RequiredErrorShownForField, `${label} should show required validation before ${purchaseLabel}`, {
-                        targetPath: requiredField.selector,
-                    }),
-                    this.makeExpectation(ExpectationType.PageResponsive, `Page should remain responsive when ${purchaseLabel} is blocked by missing ${label}`),
-                ]),
-            ],
-            globalExpectations: this.defaultFlowExpectations(`${label} should be enforced before ${purchaseLabel}`),
-            uid: context.uid,
-            generatedKey: this.buildGeneratedKey("variant-guard", context.currentPageStateId, item.selector, requiredField.selector, purchaseAction.selector),
-        };
-    }
-    findRequiredVariantField(item, forms) {
-        for (const form of forms) {
-            const field = form.fields.find(field => field.selector === item.selector &&
-                field.required &&
-                this.isSearchField(field) === false);
-            if (field)
-                return field;
-        }
-        return undefined;
-    }
-    buildDisclosureToggleTestInteraction(item, startingPath, sizeClass, uid, startingPageStateId) {
-        const label = this.describeActionableItem(item);
-        const replaySelector = buildReplaySelectorFromActionableItem(item);
-        return {
-            title: `Toggle disclosure ${label}`,
-            type: "interaction",
-            sizeClass,
-            surface_tags: ["disclosure", "click"],
-            priority: 3,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Click,
-                        path: replaySelector,
-                        playwrightCode: `await page.click('${replaySelector}')`,
-                        description: `Toggle disclosure ${label}`,
-                    },
-                    expectations: [
-                        this.makeExpectation("expanded_state_changed", "Clicking the disclosure should toggle its expanded state", {
-                            targetPath: replaySelector,
-                        }),
-                    ],
-                    description: `Toggle disclosure ${label}`,
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Disclosure interaction should complete without runtime errors"),
-            uid,
-            generatedKey: this.buildGeneratedKey("disclosure-click", startingPageStateId, replaySelector),
-        };
-    }
-    buildKeyboardActivateTestInteraction(item, key, titlePrefix, expectations, startingPath, sizeClass, uid, startingPageStateId) {
-        const label = this.describeActionableItem(item);
-        const replaySelector = buildReplaySelectorFromActionableItem(item);
-        return {
-            title: `${titlePrefix} ${label}`,
-            type: "interaction",
-            sizeClass,
-            surface_tags: [
-                "keyboard",
-                key.trim() === "" ? "space" : key.toLowerCase(),
-            ],
-            priority: 3,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Focus,
-                        path: replaySelector,
-                        playwrightCode: `await page.locator('${replaySelector}').focus()`,
-                        description: `Focus ${label}`,
-                    },
-                    expectations: [
-                        this.makeExpectation(ExpectationType.ElementFocused, `${label} should be keyboard-focusable`, {
-                            targetPath: replaySelector,
-                        }),
-                    ],
-                    description: `Focus ${label}`,
-                    continueOnFailure: false,
-                },
-                {
-                    action: {
-                        actionType: PlaywrightAction.Press,
-                        value: key,
-                        playwrightCode: `await page.keyboard.press('${key === " " ? "Space" : key}')`,
-                        description: `${titlePrefix} ${label}`,
-                    },
-                    expectations,
-                    description: `${titlePrefix} ${label}`,
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Keyboard activation should complete without runtime errors"),
-            uid,
-            generatedKey: this.buildGeneratedKey("keyboard", startingPageStateId, key === " " ? "space" : key, replaySelector),
-        };
-    }
-    buildDialogCloseTestInteraction(item, startingPath, sizeClass, uid, startingPageStateId) {
-        const label = this.describeActionableItem(item);
-        const replaySelector = buildReplaySelectorFromActionableItem(item);
-        return {
-            title: `Close dialog via ${label}`,
-            type: "interaction",
-            sizeClass,
-            surface_tags: ["dialog", "close"],
-            priority: 2,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Click,
-                        path: replaySelector,
-                        playwrightCode: `await page.click('${replaySelector}')`,
-                        description: `Close dialog via ${label}`,
-                    },
-                    expectations: [
-                        this.makeExpectation("dialog_closed", "Close action should dismiss the open dialog"),
-                        this.makeExpectation("focus_returned", "Focus should return after the dialog closes"),
-                    ],
-                    description: `Close dialog via ${label}`,
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Dialog should close cleanly"),
-            uid,
-            generatedKey: this.buildGeneratedKey("dialog-close", startingPageStateId, replaySelector),
-        };
-    }
-    buildEscapeDialogTestInteraction(startingPath, sizeClass, uid, startingPageStateId) {
-        return {
-            title: "Close dialog with Escape",
-            type: "interaction",
-            sizeClass,
-            surface_tags: ["dialog", "escape"],
-            priority: 2,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType: PlaywrightAction.Press,
-                        value: "Escape",
-                        playwrightCode: "await page.keyboard.press('Escape')",
-                        description: "Press Escape",
-                    },
-                    expectations: [
-                        this.makeExpectation("dialog_closed", "Escape should dismiss the open dialog"),
-                        this.makeExpectation("focus_returned", "Focus should return after Escape closes the dialog"),
-                    ],
-                    description: "Press Escape",
-                    continueOnFailure: false,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations("Dialog should close on Escape without runtime errors"),
-            uid,
-            generatedKey: this.buildGeneratedKey("dialog-escape", startingPageStateId, startingPath),
-        };
-    }
-    shouldUseDirectControlInteraction(item) {
-        const role = (item.role ?? "").toLowerCase();
-        const inputType = (item.inputType ?? "").toLowerCase();
-        return (this.looksVisuallyDisabledButEnabled(item) ||
-            item.actionKind === "fill" ||
-            item.actionKind === "select" ||
-            item.actionKind === "radio_select" ||
-            role === "tab" ||
-            role === "radio" ||
-            role === "checkbox" ||
-            role === "switch" ||
-            inputType === "radio" ||
-            inputType === "checkbox");
-    }
-    buildControlInteractionTestInteraction(item, startingPath, sizeClass, uid, startingPageStateId, dependencyTestInteractionId) {
-        const label = this.describeActionableItem(item);
-        const replaySelector = buildReplaySelectorFromActionableItem(item);
-        const role = (item.role ?? "").toLowerCase();
-        const inputType = (item.inputType ?? "").toLowerCase();
-        const isTab = role === "tab";
-        const isFillControl = item.actionKind === "fill";
-        const isSelectControl = item.actionKind === "select";
-        const isRadioControl = item.actionKind === "radio_select" ||
-            role === "radio" ||
-            inputType === "radio";
-        const isCheckboxControl = role === "checkbox" || role === "switch" || inputType === "checkbox";
-        const expectsChecked = isRadioControl || isCheckboxControl || isTab;
-        const expectsInputValue = isFillControl || isSelectControl;
-        const plannedValue = isSelectControl
-            ? this.extractSelectableValue(item)
-            : isFillControl
-                ? fillValuePlanner.planValue(item)
-                : undefined;
-        const isImmutable = this.looksVisuallyDisabledButEnabled(item);
-        let actionType = PlaywrightAction.Click;
-        let actionValue;
-        let playwrightCode = `await page.click('${replaySelector}')`;
-        let description = `${isTab ? "Select" : "Activate"} ${label}`;
-        if (isFillControl) {
-            actionType = PlaywrightAction.Type;
-            actionValue = plannedValue;
-            playwrightCode = `await page.locator('${replaySelector}').type('${this.escapeSingleQuotes(plannedValue ?? "")}')`;
-            description = `Type into ${label}`;
-        }
-        else if (isSelectControl) {
-            actionType = PlaywrightAction.SelectOption;
-            actionValue = plannedValue;
-            playwrightCode = `await page.locator('${replaySelector}').selectOption('${this.escapeSingleQuotes(plannedValue ?? "")}')`;
-            description = `Select ${label}`;
-        }
-        else if (isRadioControl) {
-            actionType = PlaywrightAction.Click;
-            playwrightCode = `await page.click('${replaySelector}')`;
-            description = `Select ${label}`;
-        }
-        const expectations = isImmutable
-            ? this.buildImmutableControlExpectations(item, label, replaySelector)
-            : expectsInputValue
-                ? [
-                    this.makeExpectation(ExpectationType.InputValue, `${description} should update the control value`, {
-                        targetPath: replaySelector,
-                        expectedValue: plannedValue,
-                    }),
-                ]
-                : expectsChecked
-                    ? [
-                        this.makeExpectation(ExpectationType.ElementChecked, `${label} should react to user input`, {
-                            targetPath: replaySelector,
-                        }),
-                    ]
-                    : [];
-        return {
-            title: isImmutable ? `Visually Disabled ${description}` : description,
-            type: "interaction",
-            sizeClass,
-            surface_tags: [
-                "interaction",
-                isImmutable ? "visually-disabled" : "enabled",
-                role || inputType || item.actionKind || "control",
-            ],
-            priority: 3,
-            dependencyTestInteractionId,
-            startingPageStateId,
-            startingPath,
-            steps: [
-                {
-                    action: {
-                        actionType,
-                        path: replaySelector,
-                        value: actionValue,
-                        playwrightCode,
-                        description,
-                    },
-                    expectations,
-                    description,
-                    continueOnFailure: isImmutable,
-                },
-            ],
-            globalExpectations: this.defaultFlowExpectations(isImmutable
-                ? `${label} should remain non-interactive despite appearing disabled`
-                : `${label} should react without runtime errors`),
-            uid,
-            generatedKey: this.buildGeneratedKey("control", startingPageStateId, dependencyTestInteractionId, isImmutable ? "immutable" : "enabled", role || inputType || item.actionKind || "control", replaySelector),
-        };
-    }
-    buildImmutableControlExpectations(item, label, replaySelector) {
-        const role = (item.role ?? "").toLowerCase();
-        const inputType = (item.inputType ?? "").toLowerCase();
-        if (item.actionKind === "fill" || item.actionKind === "select") {
-            return [
-                this.makeExpectation(ExpectationType.InputValue, `${label} should not respond to user input while it appears disabled`, {
-                    targetPath: replaySelector,
-                    expectNoChange: true,
-                }),
-            ];
-        }
-        if (role === "tab" ||
-            role === "radio" ||
-            role === "checkbox" ||
-            role === "switch" ||
-            inputType === "radio" ||
-            inputType === "checkbox" ||
-            item.actionKind === "radio_select") {
-            return [
-                this.makeExpectation(ExpectationType.ElementChecked, `${label} should not change state while it appears disabled`, {
-                    targetPath: replaySelector,
-                    expectNoChange: true,
-                }),
-            ];
-        }
-        return [
-            this.makeExpectation(ExpectationType.UrlUnchanged, `${label} should not trigger navigation while it appears disabled`, {
-                expectNoChange: true,
-            }),
-        ];
-    }
-    extractSelectableValue(item) {
-        const rawOptions = item.attributes?.options;
-        const parsedOptions = Array.isArray(rawOptions)
-            ? rawOptions
-            : typeof rawOptions === "string"
-                ? this.parseSelectOptions(rawOptions)
-                : [];
-        return parsedOptions.find((value) => typeof value === "string" && value.trim().length > 0);
-    }
-    parseSelectOptions(rawOptions) {
-        try {
-            const parsed = JSON.parse(rawOptions);
-            return Array.isArray(parsed) ? parsed.filter(Boolean) : [];
-        }
-        catch (err) {
-            logAnalyzer("parse-select-options:json-fallback", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return rawOptions
-                .split(",")
-                .map(value => value.trim())
-                .filter(Boolean);
-        }
-    }
-    looksVisuallyDisabledButEnabled(item) {
-        if (item.disabled)
-            return false;
-        const attrs = Object.entries(item.attributes ?? {})
-            .map(([key, value]) => `${key}=${String(value)}`)
-            .join(" ")
-            .toLowerCase();
-        return this.hasDisabledAppearanceSignal(attrs);
-    }
-    looksVisuallyDisabledField(field) {
-        if (field.disabled)
-            return false;
-        return this.hasDisabledAppearanceSignal((field.appearanceHint ?? "").toLowerCase());
-    }
-    hasDisabledAppearanceSignal(value) {
-        if (!value)
-            return false;
-        return (value.includes("aria-disabled=true") ||
-            value.includes("cursor-not-allowed") ||
-            value.includes("pointer-events:none") ||
-            value.includes("pointer-events: none") ||
-            value.includes("opacity-50") ||
-            value.includes("opacity:0.5") ||
-            value.includes("opacity: 0.5") ||
-            value.includes("opacity-40") ||
-            value.includes("disabled"));
-    }
-    describeActionableItem(item) {
-        const described = (item.accessibleName ||
-            item.textContent ||
-            String(item.attributes?._containerTitle ?? "") ||
-            String(item.attributes?.labelText ?? "") ||
-            String(item.attributes?.placeholder ?? "")).trim();
-        if (described)
-            return described;
-        const selector = item.selector ?? "";
-        if (selector.includes("data-tmnc-id")) {
-            const role = item.role?.trim();
-            const inputType = item.inputType?.trim();
-            if (role)
-                return role;
-            if (inputType)
-                return inputType;
-            if (item.actionKind === "navigate")
-                return "link";
-            if (item.actionKind === "fill")
-                return "input";
-            if (item.actionKind === "select")
-                return "select";
-            return "control";
-        }
-        return selector || item.actionKind || "control";
-    }
-    semanticText(item) {
-        return [
-            item.accessibleName || "",
-            item.textContent || "",
-            String(item.attributes?.labelText ?? ""),
-            String(item.attributes?.placeholder ?? ""),
-            String(item.attributes?.name ?? ""),
-            String(item.attributes?.id ?? ""),
-            String(item.attributes?._containerTitle ?? ""),
-            String(item.attributes?._containerCtaStyle ?? ""),
-            item.href || "",
-            item.selector,
-        ]
-            .join(" ")
-            .toLowerCase();
-    }
-    /**
-     * Max representatives per action style.  Product grids can have dozens of
-     * cards each producing a unique container fingerprint (because the product
-     * title differs), but the CTA buttons ("ADD TO CART", "Select Options") are
-     * functionally identical.  Capping per style prevents 14× duplicate hover
-     * tests for the same button type across different cards.
-     */
-    static MAX_REPS_PER_STYLE = 2;
-    selectRepresentativeItems(items, maxPerStyle = PageAnalyzer.MAX_REPS_PER_STYLE) {
-        const groups = new Map();
-        const passthrough = [];
-        for (const item of items) {
-            const containerFingerprint = String(item.attributes?._containerFingerprint ?? "").trim();
-            if (!containerFingerprint) {
-                passthrough.push(item);
-                continue;
-            }
-            const key = `${containerFingerprint}|${this.representativeActionStyle(item)}`;
-            const bucket = groups.get(key) ?? [];
-            bucket.push(item);
-            groups.set(key, bucket);
-        }
-        const representatives = Array.from(groups.values()).map(group => this.pickRepresentativeItem(group));
-        // Cap per action style: when many different containers share the same
-        // functional action (e.g. 14 product cards each with "ADD TO CART"),
-        // keep at most maxPerStyle representatives per style.
-        // Include passthrough items in the cap — items without a container
-        // fingerprint (e.g. product links in a grid that wasn't detected as a
-        // repeated container) should still be deduplicated by functional style.
-        const allCandidates = [...passthrough, ...representatives];
-        const byStyle = new Map();
-        for (const rep of allCandidates) {
-            const style = this.representativeActionStyle(rep);
-            const bucket = byStyle.get(style) ?? [];
-            bucket.push(rep);
-            byStyle.set(style, bucket);
-        }
-        return Array.from(byStyle.values()).flatMap(group => group.length <= maxPerStyle ? group : group.slice(0, maxPerStyle));
-    }
-    representativeActionStyle(item) {
-        const text = this.semanticText(item);
-        const sourceHints = String(item.attributes?._sourceHints ?? "").toLowerCase();
-        const containerTitle = String(item.attributes?._containerTitle ?? "").toLowerCase();
-        if (sourceHints.includes("promoted-target") ||
-            sourceHints.includes("cursor-pointer")) {
-            return "tile-click";
-        }
-        if (item.actionKind === "navigate" &&
-            containerTitle &&
-            (text.includes(containerTitle) ||
-                (item.href && !this.isCheckoutItem(item)))) {
-            return "tile-click";
-        }
-        if (this.isAddToCartItem(item))
-            return "cta:add-to-cart";
-        if (/\blogin for pricing\b/.test(text))
-            return "cta:login-for-pricing";
-        if (/\bselect options\b/.test(text))
-            return "cta:select-options";
-        if (this.isCheckoutItem(item))
-            return "cta:checkout";
-        if (this.isRemoveItemAction(item))
-            return "cta:remove";
-        if (item.actionKind === "navigate")
-            return "navigate";
-        if (item.actionKind === "select")
-            return "select";
-        if (item.actionKind === "fill")
-            return "fill";
-        return `${item.actionKind}:${text
-            .replace(/\b[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\b/g, "email")
-            .replace(/\$\s?\d[\d,.]*/g, "price")
-            .replace(/\d+/g, "n")
-            .slice(0, 80)}`;
+        if (item.actionKind === "navigate" &&
+            containerTitle &&
+            (text.includes(containerTitle) ||
+                (item.href && !this.isCheckoutItem(item)))) {
+            return "tile-click";
+        }
+        if (this.isAddToCartItem(item))
+            return "cta:add-to-cart";
+        if (/\blogin for pricing\b/.test(text))
+            return "cta:login-for-pricing";
+        if (/\bselect options\b/.test(text))
+            return "cta:select-options";
+        if (this.isCheckoutItem(item))
+            return "cta:checkout";
+        if (this.isRemoveItemAction(item))
+            return "cta:remove";
+        if (item.actionKind === "navigate")
+            return "navigate";
+        if (item.actionKind === "select")
+            return "select";
+        if (item.actionKind === "fill")
+            return "fill";
+        return `${item.actionKind}:${text
+            .replace(/\b[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\b/g, "email")
+            .replace(/\$\s?\d[\d,.]*/g, "price")
+            .replace(/\d+/g, "n")
+            .slice(0, 80)}`;
     }
     pickRepresentativeItem(items) {
         return [...items].sort((left, right) => {
@@ -2568,260 +404,5 @@ export class PageAnalyzer {
     isRemoveItemAction(item) {
         return /\b(remove|delete|trash|clear item|remove item|dismiss|archive|hide item|close item)\b/.test(this.semanticText(item));
     }
-    estimateCollectionCount(html) {
-        const tableRows = (html.match(/<tr\b/gi) ?? []).length;
-        if (tableRows > 0)
-            return tableRows;
-        const listItems = (html.match(/<li\b/gi) ?? []).length;
-        if (listItems > 0)
-            return listItems;
-        const cards = (html.match(/<(?:article|section|div)\b[^>]*(?:product|card|result|item|row)[^>]*>/gi) ?? []).length;
-        return cards;
-    }
-    isAuthEntryItem(item) {
-        return /\b(sign up|register|create account|sign in|log in|login)\b/.test(this.semanticText(item));
-    }
-    isProtectedActionItem(item) {
-        return /\b(checkout|pricing|view price|account|settings|billing|subscription|dashboard|admin|manage account|saved items|favorites|download)\b/.test(this.semanticText(item));
-    }
-    isLogoutAction(item) {
-        return /\b(log out|logout|sign out)\b/.test(this.semanticText(item));
-    }
-    isRetryAction(item) {
-        return /\b(retry|try again|resend|send again|reload|refresh|reconnect|resume)\b/.test(this.semanticText(item));
-    }
-    isCreateCollectionAction(item) {
-        const text = this.semanticText(item);
-        if (this.isAddToCartItem(item))
-            return false;
-        return /\b(add row|add record|add item|new row|new record|create item|create record|add another|new item)\b/.test(text);
-    }
-    isMediaOpenItem(item) {
-        const text = this.semanticText(item);
-        return (item.tagName === "VIDEO" ||
-            item.tagName === "AUDIO" ||
-            /\b(image|photo|gallery|video|play|watch|zoom|preview)\b/.test(text));
-    }
-    isVideoLikeItem(item) {
-        return (item.tagName === "VIDEO" ||
-            /\b(video|play|watch)\b/.test(this.semanticText(item)));
-    }
-    isQuantityAction(item) {
-        return /\b(qty|quantity|increase|decrease|increment|decrement|plus|minus)\b/.test(this.semanticText(item));
-    }
-    inferQuantityDelta(item) {
-        const text = this.semanticText(item);
-        if (/\b(decrease|decrement|minus|remove one|lower qty|lower quantity)\b/.test(text)) {
-            return -1;
-        }
-        if (/\b(increase|increment|plus|add one|raise qty|raise quantity)\b/.test(text)) {
-            return 1;
-        }
-        return undefined;
-    }
-    isFilterAction(item) {
-        return /\b(filter|refine|apply filter|show results|category|brand|size|color|price)\b/.test(this.semanticText(item));
-    }
-    isSearchClearItem(item) {
-        return /\b(clear search|clear results|reset search|reset filters|clear|reset)\b/.test(this.semanticText(item));
-    }
-    isSortAction(item) {
-        return /\b(sort|order by|best selling|price low|price high|newest|featured)\b/.test(this.semanticText(item));
-    }
-    isPaginationAction(item) {
-        return /\b(next|previous|prev|page \d+|load more|show more|older|newer)\b/.test(this.semanticText(item));
-    }
-    isVariantSelector(item) {
-        if (item.actionKind !== "select") {
-            return false;
-        }
-        return /\b(variant|option|size|color|colour|style|material|finish|width|length|currency|language|locale|region|country|sort|order|per\s*page|show|display|view)\b/.test(this.semanticText(item));
-    }
-    isDialogCloseItem(item) {
-        return /\b(close|dismiss|cancel|done|x)\b/.test(this.semanticText(item));
-    }
-    pageHasOpenDialog(html) {
-        return (/role=["']dialog["']/i.test(html) ||
-            /role=["']alertdialog["']/i.test(html) ||
-            /aria-modal=["']true["']/i.test(html) ||
-            /\bmodal\b/i.test(html) ||
-            /\boverlay\b/i.test(html));
-    }
-    isDisclosureItem(item) {
-        const expanded = String(item.attributes?.["aria-expanded"] ?? "").toLowerCase();
-        return expanded === "true" || expanded === "false";
-    }
-    isKeyboardPrimaryAction(item) {
-        const role = (item.role ?? "").toLowerCase();
-        return (item.actionKind === "navigate" ||
-            role === "button" ||
-            role === "link" ||
-            role === "menuitem" ||
-            item.tagName === "BUTTON" ||
-            item.tagName === "A");
-    }
-    isKeyboardToggleAction(item) {
-        const role = (item.role ?? "").toLowerCase();
-        const inputType = (item.inputType ?? "").toLowerCase();
-        return (role === "checkbox" ||
-            role === "switch" ||
-            role === "radio" ||
-            inputType === "checkbox" ||
-            inputType === "radio");
-    }
-    buildSemanticAction(item, description, signal) {
-        if (item.actionKind === "select") {
-            const value = this.extractSelectableValue(item);
-            return {
-                actionType: PlaywrightAction.SelectOption,
-                path: item.selector,
-                value,
-                playwrightCode: `await page.locator('${item.selector}').selectOption('${this.escapeSingleQuotes(value ?? "")}')`,
-                description: `${description}: ${signal}`,
-            };
-        }
-        if (item.actionKind === "fill") {
-            const value = this.isQuantityAction(item)
-                ? "2"
-                : fillValuePlanner.planValue(item);
-            return {
-                actionType: PlaywrightAction.Type,
-                path: item.selector,
-                value,
-                playwrightCode: `await page.locator('${item.selector}').type('${this.escapeSingleQuotes(value)}')`,
-                description: `${description}: ${signal}`,
-            };
-        }
-        return {
-            actionType: PlaywrightAction.Click,
-            path: item.selector,
-            playwrightCode: `await page.click('${item.selector}')`,
-            description: `${description}: ${signal}`,
-        };
-    }
-    makeExpectation(expectationType, description, extras) {
-        return {
-            expectationType,
-            severity: ExpectationSeverity.ShouldPass,
-            description,
-            playwrightCode: "// evaluated by TesterExpertise",
-            ...(extras ?? {}),
-        };
-    }
-    isSelectLike(field) {
-        return field.type === "select" || field.type === "select-one";
-    }
-    isSkippableFieldType(field) {
-        return ["hidden", "submit", "button", "image", "file"].includes(field.type);
-    }
-    fieldLabel(field) {
-        return field.label || field.name || field.selector;
-    }
-    improbableSearchQuery() {
-        return "zzzz-no-results-testomniac";
-    }
-    slugify(value) {
-        return (value
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .replace(/^-+|-+$/g, "") || "page");
-    }
-    escapeSingleQuotes(value) {
-        return value.replace(/'/g, "\\'");
-    }
-    extractVisibleText(html) {
-        return html
-            .replace(/<script[\s\S]*?<\/script>/gi, " ")
-            .replace(/<style[\s\S]*?<\/style>/gi, " ")
-            .replace(/<[^>]+>/g, " ")
-            .replace(/\s+/g, " ")
-            .trim();
-    }
-    detectPasswordRequirements(visibleText) {
-        const lower = visibleText.toLowerCase();
-        const requirements = {
-            requiresUppercase: false,
-            requiresLowercase: false,
-            requiresNumber: false,
-            requiresSpecial: false,
-            noSpaces: false,
-        };
-        const lengthMatch = lower.match(/(?:at least|minimum|min\.?)\s*(\d+)\s*character/i) ||
-            lower.match(/(\d+)\+?\s*character/i);
-        if (lengthMatch) {
-            requirements.minLength = Number.parseInt(lengthMatch[1], 10);
-        }
-        if (/uppercase|capital letter/i.test(lower))
-            requirements.requiresUppercase = true;
-        if (/lowercase/i.test(lower))
-            requirements.requiresLowercase = true;
-        if (/number|digit|\d/i.test(lower) &&
-            /must|require|contain|include/i.test(lower)) {
-            requirements.requiresNumber = true;
-        }
-        if (/special character|symbol|[!@#$%^&*]/i.test(lower) &&
-            /must|require|contain|include/i.test(lower)) {
-            requirements.requiresSpecial = true;
-        }
-        if (/no\s*spaces/i.test(lower))
-            requirements.noSpaces = true;
-        return requirements;
-    }
-    generatePasswordVariants(requirements) {
-        const variants = [];
-        const minimumLength = Math.max(requirements.minLength ?? 8, 8);
-        let validPassword = "Aa1!";
-        while (validPassword.length < minimumLength) {
-            validPassword += "xY2@".charAt(validPassword.length % 4);
-        }
-        if (requirements.minLength) {
-            variants.push({
-                password: validPassword.slice(0, Math.max(requirements.minLength - 1, 1)),
-                description: "too short password",
-                shouldFail: true,
-            });
-        }
-        if (requirements.requiresUppercase) {
-            variants.push({
-                password: validPassword.toLowerCase(),
-                description: "missing uppercase password",
-                shouldFail: true,
-            });
-        }
-        if (requirements.requiresLowercase) {
-            variants.push({
-                password: validPassword.toUpperCase(),
-                description: "missing lowercase password",
-                shouldFail: true,
-            });
-        }
-        if (requirements.requiresNumber) {
-            variants.push({
-                password: validPassword.replace(/\d/g, "a"),
-                description: "missing number password",
-                shouldFail: true,
-            });
-        }
-        if (requirements.requiresSpecial) {
-            variants.push({
-                password: validPassword.replace(/[^a-zA-Z0-9]/g, "a"),
-                description: "missing special character password",
-                shouldFail: true,
-            });
-        }
-        if (requirements.noSpaces) {
-            variants.push({
-                password: `${validPassword.slice(0, 4)} ${validPassword.slice(4)}`,
-                description: "password with spaces",
-                shouldFail: true,
-            });
-        }
-        variants.push({
-            password: validPassword,
-            description: "valid password",
-            shouldFail: false,
-        });
-        return variants;
-    }
 }
 //# sourceMappingURL=index.js.map