@scantrix/cli 1.0.0

package/dist/astRuleHelpers.js

@@ -0,0 +1,1451 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findVariableShadowing = findVariableShadowing;
+exports.findCustomAssertionWrappers = findCustomAssertionWrappers;
+exports.findManualContextInTestBodies = findManualContextInTestBodies;
+exports.findTestDataMutations = findTestDataMutations;
+exports.findMissingPlaywrightAwaits = findMissingPlaywrightAwaits;
+exports.extractRelativeImportBindings = extractRelativeImportBindings;
+exports.findSleepWrapperExports = findSleepWrapperExports;
+exports.findClassSleepMethodExports = findClassSleepMethodExports;
+exports.findDisguisedHardWaitCalls = findDisguisedHardWaitCalls;
+exports.findUnguardedRetrievalMethods = findUnguardedRetrievalMethods;
+exports.findUnguardedRetrievalMethodsInFunctions = findUnguardedRetrievalMethodsInFunctions;
+exports.analyzePomClassStructure = analyzePomClassStructure;
+exports.findLargeInlineDataLiterals = findLargeInlineDataLiterals;
+/**
+ * AST-based rule helpers for analytical scanner rules.
+ *
+ * Uses the TypeScript Compiler API (ts.createSourceFile) for accurate
+ * scope-aware detection that regex cannot reliably achieve.
+ */
+const typescript_1 = __importDefault(require("typescript"));
+// ─── Shared Utilities ────────────────────────────────────────────────
+function parseSource(filePath, content) {
+    return typescript_1.default.createSourceFile(filePath, content, typescript_1.default.ScriptTarget.Latest, true);
+}
+/** Check if a CallExpression matches `obj.method()` */
+function isMethodCall(node, obj, method) {
+    const expr = node.expression;
+    if (!typescript_1.default.isPropertyAccessExpression(expr))
+        return false;
+    if (expr.name.text !== method)
+        return false;
+    if (typescript_1.default.isIdentifier(expr.expression)) {
+        return expr.expression.text === obj;
+    }
+    return false;
+}
+/** Check if a CallExpression matches `obj.method()` OR just `func()` */
+function isCallTo(node, name) {
+    if (typescript_1.default.isIdentifier(node.expression)) {
+        return node.expression.text === name;
+    }
+    return false;
+}
+/** Get the root identifier from a PropertyAccessExpression chain */
+function getRootIdentifier(node) {
+    if (typescript_1.default.isIdentifier(node))
+        return node.text;
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        return getRootIdentifier(node.expression);
+    }
+    return undefined;
+}
+/** Get 1-based line number from AST position */
+function lineOf(sf, pos) {
+    return sf.getLineAndCharacterOfPosition(pos).line + 1;
+}
+/** Get the declaration keyword text for a variable declaration */
+function declKeyword(decl) {
+    const list = decl.parent;
+    if (!typescript_1.default.isVariableDeclarationList(list))
+        return "unknown";
+    if (list.flags & typescript_1.default.NodeFlags.Const)
+        return "const";
+    if (list.flags & typescript_1.default.NodeFlags.Let)
+        return "let";
+    return "var";
+}
+// ─── PW-STABILITY-007: Variable Shadowing Between Test Scopes ────────
+/**
+ * Detect variable shadowing between describe-scope and nested
+ * test/hook callbacks. Outer `let`/`var` declarations that are
+ * shadowed by inner `const`/`let`/`var` of the same name cause
+ * the outer to stay undefined — runtime crash in afterAll.
+ */
+function findVariableShadowing(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        // Find test.describe(..., callback)
+        if (typescript_1.default.isCallExpression(node) &&
+            isMethodCall(node, "test", "describe")) {
+            const callback = node.arguments[1];
+            if (callback &&
+                (typescript_1.default.isArrowFunction(callback) ||
+                    typescript_1.default.isFunctionExpression(callback)) &&
+                callback.body &&
+                typescript_1.default.isBlock(callback.body)) {
+                analyzeDescribeBlock(sf, callback.body, results);
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(sf);
+    return results;
+}
+function analyzeDescribeBlock(sf, block, results) {
+    // Collect top-level let/var declarations in describe scope
+    const outerVars = new Map();
+    for (const stmt of block.statements) {
+        if (typescript_1.default.isVariableStatement(stmt)) {
+            const keyword = declKeyword(stmt.declarationList.declarations[0]);
+            if (keyword === "let" || keyword === "var") {
+                for (const decl of stmt.declarationList.declarations) {
+                    if (typescript_1.default.isIdentifier(decl.name)) {
+                        const name = decl.name.text;
+                        // Skip intentionally unused vars (prefixed with _)
+                        if (name.startsWith("_"))
+                            continue;
+                        outerVars.set(name, {
+                            line: lineOf(sf, decl.getStart()),
+                            kind: keyword,
+                            decl,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (outerVars.size === 0)
+        return;
+    // Walk nested test/hook callbacks for shadowing declarations
+    for (const stmt of block.statements) {
+        if (!typescript_1.default.isExpressionStatement(stmt))
+            continue;
+        const expr = stmt.expression;
+        if (!typescript_1.default.isCallExpression(expr))
+            continue;
+        // Match test(), test.only(), test.beforeAll(), test.afterAll(), etc.
+        const callee = expr.expression;
+        const isTestLikeCall = isCallTo(expr, "test") ||
+            (typescript_1.default.isPropertyAccessExpression(callee) &&
+                typescript_1.default.isIdentifier(callee.expression) &&
+                callee.expression.text === "test");
+        if (!isTestLikeCall)
+            continue;
+        // Find the callback argument (last arg that is a function)
+        for (const arg of expr.arguments) {
+            if ((typescript_1.default.isArrowFunction(arg) || typescript_1.default.isFunctionExpression(arg)) &&
+                arg.body &&
+                typescript_1.default.isBlock(arg.body)) {
+                collectShadowingInBlock(sf, arg.body, outerVars, results);
+            }
+        }
+    }
+}
+function collectShadowingInBlock(sf, block, outerVars, results) {
+    function walk(node) {
+        if (typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+            const name = node.name.text;
+            const outer = outerVars.get(name);
+            if (outer) {
+                const innerKind = declKeyword(node);
+                results.push({
+                    file: sf.fileName,
+                    outerLine: outer.line,
+                    innerLine: lineOf(sf, node.getStart()),
+                    name,
+                    outerKind: outer.kind,
+                    innerKind,
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    walk(block);
+}
+// ─── PW-FLAKE-007: Custom Assertion Wrappers ─────────────────────────
+const ASSERTION_NAME_RE = /^(compare|assert|verify|validate|check|ensure|confirm)/i;
+/**
+ * Detect custom assertion wrappers imported from relative paths
+ * that bypass Playwright's auto-retrying expect().
+ */
+function findCustomAssertionWrappers(filePath, content) {
+    const sf = parseSource(filePath, content);
+    // 1. Collect assertion-like imports from relative paths
+    const assertionBindings = new Map(); // name → module path
+    for (const stmt of sf.statements) {
+        if (!typescript_1.default.isImportDeclaration(stmt))
+            continue;
+        const specifier = stmt.moduleSpecifier;
+        if (!typescript_1.default.isStringLiteral(specifier))
+            continue;
+        const modulePath = specifier.text;
+        // Only relative imports
+        if (!modulePath.startsWith("./") && !modulePath.startsWith("../"))
+            continue;
+        if (stmt.importClause) {
+            // Named imports: import { compareFoo } from './utils'
+            const namedBindings = stmt.importClause.namedBindings;
+            if (namedBindings && typescript_1.default.isNamedImports(namedBindings)) {
+                for (const el of namedBindings.elements) {
+                    const name = el.name.text;
+                    if (ASSERTION_NAME_RE.test(name)) {
+                        assertionBindings.set(name, modulePath);
+                    }
+                }
+            }
+            // Default import: import compareFoo from './utils'
+            if (stmt.importClause.name) {
+                const name = stmt.importClause.name.text;
+                if (ASSERTION_NAME_RE.test(name)) {
+                    assertionBindings.set(name, modulePath);
+                }
+            }
+        }
+    }
+    if (assertionBindings.size === 0)
+        return [];
+    // 2. Count calls to each assertion binding AND expect() calls AND test() blocks
+    const callCounts = new Map();
+    let expectCount = 0;
+    let testCount = 0;
+    function walk(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            // Count expect()
+            if (typescript_1.default.isIdentifier(node.expression) && node.expression.text === "expect") {
+                expectCount++;
+            }
+            // Count test() / test.only()
+            if (isCallTo(node, "test") || isMethodCall(node, "test", "only")) {
+                testCount++;
+            }
+            // Count assertion binding calls
+            if (typescript_1.default.isIdentifier(node.expression)) {
+                const name = node.expression.text;
+                if (assertionBindings.has(name)) {
+                    callCounts.set(name, (callCounts.get(name) ?? 0) + 1);
+                }
+            }
+            // Also check await expressions: await compareFoo(...)
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    walk(sf);
+    // 3. Flag if custom calls ≥ 2 AND (expect count < test count OR custom calls > expect count)
+    const results = [];
+    for (const [name, modulePath] of assertionBindings) {
+        const count = callCounts.get(name) ?? 0;
+        if (count >= 2 && (expectCount < testCount || count > expectCount)) {
+            results.push({
+                file: filePath,
+                importName: name,
+                importPath: modulePath,
+                callCount: count,
+                expectCount,
+                testCount,
+            });
+        }
+    }
+    return results;
+}
+// ─── PW-STABILITY-008: Manual Browser Context in Test Bodies ─────────
+/**
+ * Check if a node is inside a VariableDeclaration within the given boundary.
+ * Used to distinguish locally-declared contexts (const/let/var inside test body)
+ * from assignments to outer-scoped variables (describe-level, accessible to afterAll).
+ */
+function isLocallyDeclared(node, boundary) {
+    let current = node.parent;
+    while (current && current !== boundary) {
+        if (typescript_1.default.isVariableDeclaration(current))
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Detect `browser.newContext()` calls inside test() callbacks.
+ * Fixtures handle lifecycle automatically (including failure scenarios).
+ *
+ * Only flags calls where the context is locally declared (const/let/var)
+ * inside the test body. Assignments to outer-scoped variables (declared in
+ * describe scope) are skipped because afterAll/afterEach can access them
+ * for cleanup.
+ */
+function findManualContextInTestBodies(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        if (!typescript_1.default.isCallExpression(node)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Match test(...) or test.only(...)
+        const isTestCall = isCallTo(node, "test") || isMethodCall(node, "test", "only");
+        if (!isTestCall) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Skip hooks: test.beforeAll, test.afterAll, test.beforeEach, test.afterEach
+        if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+            const method = node.expression.name.text;
+            if (method === "beforeAll" ||
+                method === "afterAll" ||
+                method === "beforeEach" ||
+                method === "afterEach" ||
+                method === "describe") {
+                typescript_1.default.forEachChild(node, visit);
+                return;
+            }
+        }
+        // Extract test name from 1st argument
+        let testName = "(unnamed)";
+        if (node.arguments.length > 0 && typescript_1.default.isStringLiteral(node.arguments[0])) {
+            testName = node.arguments[0].text;
+        }
+        // Find the callback (2nd or last arg that is a function)
+        let callback;
+        for (const arg of node.arguments) {
+            if (typescript_1.default.isArrowFunction(arg) || typescript_1.default.isFunctionExpression(arg)) {
+                callback = arg;
+            }
+        }
+        if (!callback || !callback.body || !typescript_1.default.isBlock(callback.body)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Count browser.newContext() and request.newContext() calls in the callback body.
+        // Only count calls where the result is locally declared (const/let/var) inside
+        // the test body. If assigned to an outer-scoped variable (describe level),
+        // afterAll/afterEach can clean it up — skip those.
+        const bodyBlock = callback.body;
+        let newContextCount = 0;
+        let firstLine = 0;
+        function walkBody(n) {
+            if (typescript_1.default.isCallExpression(n) &&
+                typescript_1.default.isPropertyAccessExpression(n.expression) &&
+                n.expression.name.text === "newContext" &&
+                typescript_1.default.isIdentifier(n.expression.expression) &&
+                (n.expression.expression.text === "browser" ||
+                    n.expression.expression.text === "request")) {
+                if (isLocallyDeclared(n, bodyBlock)) {
+                    newContextCount++;
+                    if (firstLine === 0) {
+                        firstLine = lineOf(sf, n.getStart());
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(n, walkBody);
+        }
+        walkBody(bodyBlock);
+        if (newContextCount > 0) {
+            results.push({
+                file: filePath,
+                line: firstLine,
+                testName,
+                count: newContextCount,
+            });
+        }
+        // Don't recurse into the test callback again (already walked)
+    }
+    visit(sf);
+    return results;
+}
+// ─── ARCH-012: Mutating Imported Test Data Objects ───────────────────
+const DATA_PATH_RE = /(?:data|fixture|constant|config)/i;
+/**
+ * Detect mutations of imported test-data objects (namespace or named imports
+ * from relative paths). Mutating shared module-level objects breaks
+ * parallel execution.
+ */
+function findTestDataMutations(filePath, content) {
+    const sf = parseSource(filePath, content);
+    // 1. Collect import bindings
+    const importBindings = new Map(); // binding name → module path
+    for (const stmt of sf.statements) {
+        if (!typescript_1.default.isImportDeclaration(stmt))
+            continue;
+        const specifier = stmt.moduleSpecifier;
+        if (!typescript_1.default.isStringLiteral(specifier))
+            continue;
+        const modulePath = specifier.text;
+        // Only relative imports
+        if (!modulePath.startsWith("./") && !modulePath.startsWith("../"))
+            continue;
+        if (stmt.importClause) {
+            const namedBindings = stmt.importClause.namedBindings;
+            // Namespace imports: import * as testData from './data'
+            if (namedBindings && typescript_1.default.isNamespaceImport(namedBindings)) {
+                importBindings.set(namedBindings.name.text, modulePath);
+            }
+            // Named imports from data-like paths
+            if (namedBindings &&
+                typescript_1.default.isNamedImports(namedBindings) &&
+                DATA_PATH_RE.test(modulePath)) {
+                for (const el of namedBindings.elements) {
+                    importBindings.set(el.name.text, modulePath);
+                }
+            }
+            // Default import from data-like paths
+            if (stmt.importClause.name && DATA_PATH_RE.test(modulePath)) {
+                importBindings.set(stmt.importClause.name.text, modulePath);
+            }
+        }
+    }
+    if (importBindings.size === 0)
+        return [];
+    // 2. Find assignments where left side is a property of an imported binding
+    const mutations = new Map();
+    function walk(node) {
+        if (typescript_1.default.isBinaryExpression(node) &&
+            node.operatorToken.kind === typescript_1.default.SyntaxKind.EqualsToken) {
+            const left = node.left;
+            if (typescript_1.default.isPropertyAccessExpression(left) || typescript_1.default.isElementAccessExpression(left)) {
+                const root = getRootIdentifier(left);
+                if (root && importBindings.has(root)) {
+                    const entry = mutations.get(root) ?? {
+                        importPath: importBindings.get(root),
+                        lines: [],
+                        snippets: [],
+                    };
+                    entry.lines.push(lineOf(sf, node.getStart()));
+                    const lineText = content
+                        .split(/\r?\n/)[lineOf(sf, node.getStart()) - 1]?.trim()
+                        .slice(0, 120);
+                    entry.snippets.push(lineText ?? "");
+                    mutations.set(root, entry);
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    walk(sf);
+    // 3. Build results
+    const results = [];
+    for (const [binding, data] of mutations) {
+        results.push({
+            file: filePath,
+            line: data.lines[0],
+            bindingName: binding,
+            importPath: data.importPath,
+            mutationCount: data.lines.length,
+            snippet: `${data.lines.length} mutation(s) of '${binding}' from ${data.importPath}`,
+        });
+    }
+    return results;
+}
+// ─── PW-FLAKE-008: Missing await on Async Playwright APIs ───────────
+const ASYNC_MATCHERS = new Set([
+    "toBeAttached", "toBeChecked", "toBeDisabled", "toBeEditable",
+    "toBeEmpty", "toBeEnabled", "toBeFocused", "toBeHidden",
+    "toBeInViewport", "toBeVisible", "toContainText",
+    "toHaveAccessibleDescription", "toHaveAccessibleName",
+    "toHaveAttribute", "toHaveCSS", "toHaveClass", "toHaveCount",
+    "toHaveId", "toHaveJSProperty", "toHaveRole", "toHaveScreenshot",
+    "toHaveText", "toHaveTitle", "toHaveURL", "toHaveValue",
+    "toHaveValues", "toPass",
+]);
+/**
+ * Walk a call-expression chain and check whether the root is
+ * `expect(...)`, `expect.soft(...)`, or `expect.poll(...)`.
+ * Returns the kind if found, undefined otherwise.
+ */
+function getExpectChainKind(node) {
+    // Walk the expression to find the root call
+    let current = node.expression;
+    // Peel off PropertyAccessExpression layers: e.g. expect(...).not.toBeVisible
+    while (typescript_1.default.isPropertyAccessExpression(current)) {
+        current = current.expression;
+    }
+    // Now `current` should be the root call: expect(...) / expect.soft(...) / expect.poll(...)
+    if (!typescript_1.default.isCallExpression(current))
+        return undefined;
+    const callee = current.expression;
+    // expect(...)
+    if (typescript_1.default.isIdentifier(callee) && callee.text === "expect") {
+        return "expect";
+    }
+    // expect.soft(...) or expect.poll(...)
+    if (typescript_1.default.isPropertyAccessExpression(callee) &&
+        typescript_1.default.isIdentifier(callee.expression) &&
+        callee.expression.text === "expect") {
+        const method = callee.name.text;
+        if (method === "soft")
+            return "expect.soft";
+        if (method === "poll")
+            return "expect.poll";
+    }
+    return undefined;
+}
+/**
+ * Get the final method name from a call expression's property chain.
+ * e.g. `expect(x).not.toBeVisible()` → "toBeVisible"
+ */
+function getFinalMethodName(node) {
+    if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+        return node.expression.name.text;
+    }
+    return undefined;
+}
+/** Check if a CallExpression is `test.step(...)` */
+function isTestStepCall(node) {
+    return isMethodCall(node, "test", "step");
+}
+/**
+ * Detect missing `await` on async Playwright APIs inside test() callbacks.
+ *
+ * Catches:
+ * - `expect(locator).toBeVisible()` (and all 28 async matchers)
+ * - `expect.soft(locator).toBeVisible()` (soft assertion variants)
+ * - `expect.poll(() => ...).toBe(...)` (poll chains)
+ * - `test.step("name", async () => { ... })` (unawaited steps)
+ * - Negated forms: `expect(x).not.toBeVisible()`
+ */
+function findMissingPlaywrightAwaits(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        if (!typescript_1.default.isCallExpression(node)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Match test(...) or test.only(...)
+        const isTestCall = isCallTo(node, "test") || isMethodCall(node, "test", "only");
+        if (!isTestCall) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Skip hooks and describe
+        if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+            const method = node.expression.name.text;
+            if (method === "beforeAll" ||
+                method === "afterAll" ||
+                method === "beforeEach" ||
+                method === "afterEach" ||
+                method === "describe") {
+                typescript_1.default.forEachChild(node, visit);
+                return;
+            }
+        }
+        // Extract test name
+        let testName = "(unnamed)";
+        if (node.arguments.length > 0 && typescript_1.default.isStringLiteral(node.arguments[0])) {
+            testName = node.arguments[0].text;
+        }
+        // Find the callback
+        let callback;
+        for (const arg of node.arguments) {
+            if (typescript_1.default.isArrowFunction(arg) || typescript_1.default.isFunctionExpression(arg)) {
+                callback = arg;
+            }
+        }
+        if (!callback || !callback.body || !typescript_1.default.isBlock(callback.body)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Walk the callback body for unawaited async patterns
+        function walkBody(n) {
+            if (typescript_1.default.isExpressionStatement(n)) {
+                const expr = n.expression;
+                // If the expression is an AwaitExpression, it's properly awaited — skip
+                if (typescript_1.default.isAwaitExpression(expr)) {
+                    return;
+                }
+                if (typescript_1.default.isCallExpression(expr)) {
+                    // Check for unawaited test.step(...)
+                    if (isTestStepCall(expr)) {
+                        results.push({
+                            file: filePath,
+                            line: lineOf(sf, n.getStart()),
+                            testName,
+                            snippet: "test.step(...)",
+                        });
+                        return;
+                    }
+                    // Check for unawaited expect chain with async matcher
+                    const methodName = getFinalMethodName(expr);
+                    if (methodName) {
+                        const chainKind = getExpectChainKind(expr);
+                        if (chainKind === "expect.poll") {
+                            // Any matcher on expect.poll() is async
+                            results.push({
+                                file: filePath,
+                                line: lineOf(sf, n.getStart()),
+                                testName,
+                                snippet: `expect.poll(...).${methodName}(...)`,
+                            });
+                            return;
+                        }
+                        if ((chainKind === "expect" || chainKind === "expect.soft") &&
+                            ASYNC_MATCHERS.has(methodName)) {
+                            const prefix = chainKind === "expect.soft"
+                                ? "expect.soft(...)"
+                                : "expect(...)";
+                            results.push({
+                                file: filePath,
+                                line: lineOf(sf, n.getStart()),
+                                testName,
+                                snippet: `${prefix}.${methodName}(...)`,
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(n, walkBody);
+        }
+        walkBody(callback.body);
+        // Don't recurse into the test callback again
+    }
+    visit(sf);
+    return results;
+}
+// ─── PW-FLAKE-001 Enhancement: Disguised Hard Wait Detection ─────────
+const RETRY_INTENT_KEYWORDS = ["retry", "attempt", "backoff", "polling", "reconnect"];
+/**
+ * Extract all named/default import bindings from relative paths.
+ * Skips namespace imports (`import * as ...`) and non-relative imports.
+ */
+function extractRelativeImportBindings(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const bindings = [];
+    for (const stmt of sf.statements) {
+        if (!typescript_1.default.isImportDeclaration(stmt))
+            continue;
+        const specifier = stmt.moduleSpecifier;
+        if (!typescript_1.default.isStringLiteral(specifier))
+            continue;
+        const modulePath = specifier.text;
+        if (!modulePath.startsWith("./") && !modulePath.startsWith("../"))
+            continue;
+        if (!stmt.importClause)
+            continue;
+        // Default import
+        if (stmt.importClause.name) {
+            bindings.push({
+                localName: stmt.importClause.name.text,
+                originalName: "default",
+                modulePath,
+            });
+        }
+        const namedBindings = stmt.importClause.namedBindings;
+        if (!namedBindings)
+            continue;
+        // Skip namespace imports (import * as ...)
+        if (typescript_1.default.isNamespaceImport(namedBindings))
+            continue;
+        // Named imports
+        if (typescript_1.default.isNamedImports(namedBindings)) {
+            for (const el of namedBindings.elements) {
+                bindings.push({
+                    localName: el.name.text,
+                    originalName: el.propertyName ? el.propertyName.text : el.name.text,
+                    modulePath,
+                });
+            }
+        }
+    }
+    return bindings;
+}
+/**
+ * Check whether a function body contains a sleep pattern:
+ * - `new Promise(... => setTimeout(...))`
+ * - `waitForTimeout(...)` as a property access call
+ * - Direct `setTimeout(...)` call
+ */
+function bodyContainsSleepPattern(body) {
+    let found = false;
+    function walk(node) {
+        if (found)
+            return;
+        if (typescript_1.default.isCallExpression(node)) {
+            // Direct setTimeout(...)
+            if (typescript_1.default.isIdentifier(node.expression) && node.expression.text === "setTimeout") {
+                found = true;
+                return;
+            }
+            // *.waitForTimeout(...)
+            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === "waitForTimeout") {
+                found = true;
+                return;
+            }
+            // *.waitForNetworkIdle(...)
+            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === "waitForNetworkIdle") {
+                found = true;
+                return;
+            }
+            // *.waitForLoadState('networkidle')
+            if (typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === "waitForLoadState" &&
+                node.arguments.length > 0 &&
+                typescript_1.default.isStringLiteral(node.arguments[0]) &&
+                node.arguments[0].text === "networkidle") {
+                found = true;
+                return;
+            }
+        }
+        // new Promise(... => setTimeout(...))
+        if (typescript_1.default.isNewExpression(node) &&
+            typescript_1.default.isIdentifier(node.expression) &&
+            node.expression.text === "Promise") {
+            const args = node.arguments;
+            if (args && args.length > 0) {
+                function walkForSetTimeout(n) {
+                    if (found)
+                        return;
+                    if (typescript_1.default.isCallExpression(n) &&
+                        typescript_1.default.isIdentifier(n.expression) &&
+                        n.expression.text === "setTimeout") {
+                        found = true;
+                        return;
+                    }
+                    typescript_1.default.forEachChild(n, walkForSetTimeout);
+                }
+                for (const arg of args) {
+                    walkForSetTimeout(arg);
+                }
+            }
+            return;
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    walk(body);
+    return found;
+}
+/**
+ * Check whether a function body contains a loop with retry-intent identifiers.
+ * Used to suppress false positives on retry/polling wrappers.
+ */
+function bodyHasRetryLoop(body, sf) {
+    let hasLoop = false;
+    let hasRetryIntent = false;
+    function walk(node) {
+        if (hasLoop && hasRetryIntent)
+            return;
+        if (typescript_1.default.isWhileStatement(node) ||
+            typescript_1.default.isForStatement(node) ||
+            typescript_1.default.isForInStatement(node) ||
+            typescript_1.default.isForOfStatement(node) ||
+            typescript_1.default.isDoStatement(node)) {
+            hasLoop = true;
+        }
+        if (typescript_1.default.isIdentifier(node)) {
+            const name = node.text.toLowerCase();
+            if (RETRY_INTENT_KEYWORDS.some((kw) => name.includes(kw))) {
+                hasRetryIntent = true;
+            }
+        }
+        if (typescript_1.default.isStringLiteral(node)) {
+            const text = node.text.toLowerCase();
+            if (RETRY_INTENT_KEYWORDS.some((kw) => text.includes(kw))) {
+                hasRetryIntent = true;
+            }
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    walk(body);
+    return hasLoop && hasRetryIntent;
+}
+/**
+ * Parse a utility module and return names of exported functions whose body
+ * is a sleep wrapper (Promise-setTimeout, waitForTimeout, direct setTimeout).
+ * Excludes functions with retry/polling loop patterns (false-positive filter).
+ */
+function findSleepWrapperExports(filePath, content) {
+    const sf = parseSource(filePath, content);
+    // 1. Collect all module-level function bodies by name
+    const funcBodies = new Map();
+    // 2. Collect exported names
+    const exportedNames = new Set();
+    for (const stmt of sf.statements) {
+        // Function declarations: function foo() { ... }
+        if (typescript_1.default.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
+            funcBodies.set(stmt.name.text, stmt.body);
+            if (stmt.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword)) {
+                exportedNames.add(stmt.name.text);
+            }
+            if (stmt.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.DefaultKeyword)) {
+                exportedNames.add(stmt.name.text);
+            }
+        }
+        // Variable declarations: const foo = async () => { ... }
+        if (typescript_1.default.isVariableStatement(stmt)) {
+            const isExported = stmt.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+            for (const decl of stmt.declarationList.declarations) {
+                if (!typescript_1.default.isIdentifier(decl.name) || !decl.initializer)
+                    continue;
+                const init = decl.initializer;
+                if ((typescript_1.default.isArrowFunction(init) || typescript_1.default.isFunctionExpression(init)) &&
+                    init.body) {
+                    funcBodies.set(decl.name.text, init.body);
+                    if (isExported) {
+                        exportedNames.add(decl.name.text);
+                    }
+                }
+            }
+        }
+        // export { name1, name2 }
+        if (typescript_1.default.isExportDeclaration(stmt) &&
+            stmt.exportClause &&
+            typescript_1.default.isNamedExports(stmt.exportClause)) {
+            for (const el of stmt.exportClause.elements) {
+                const localName = el.propertyName ? el.propertyName.text : el.name.text;
+                exportedNames.add(localName);
+            }
+        }
+        // export default identifier
+        if (typescript_1.default.isExportAssignment(stmt) && typescript_1.default.isIdentifier(stmt.expression)) {
+            exportedNames.add(stmt.expression.text);
+        }
+    }
+    // 3. For each exported function, check if body is a sleep wrapper
+    const results = [];
+    for (const name of exportedNames) {
+        const body = funcBodies.get(name);
+        if (!body)
+            continue;
+        if (bodyHasRetryLoop(body, sf))
+            continue;
+        if (bodyContainsSleepPattern(body)) {
+            results.push(name);
+        }
+    }
+    return results;
+}
+/**
+ * Parse a utility module and return exported classes that contain methods
+ * whose body is a sleep wrapper (Promise-setTimeout, waitForTimeout, direct setTimeout).
+ * Excludes methods with retry/polling loop patterns (false-positive filter).
+ */
+function findClassSleepMethodExports(filePath, content) {
+    const sf = parseSource(filePath, content);
+    // Collect names exported via `export { ClassName }` or `export default ident`
+    const reExportedNames = new Set();
+    const defaultExportedNames = new Set();
+    for (const stmt of sf.statements) {
+        if (typescript_1.default.isExportDeclaration(stmt) &&
+            stmt.exportClause &&
+            typescript_1.default.isNamedExports(stmt.exportClause)) {
+            for (const el of stmt.exportClause.elements) {
+                const localName = el.propertyName ? el.propertyName.text : el.name.text;
+                reExportedNames.add(localName);
+            }
+        }
+        if (typescript_1.default.isExportAssignment(stmt) && typescript_1.default.isIdentifier(stmt.expression)) {
+            defaultExportedNames.add(stmt.expression.text);
+        }
+    }
+    const results = [];
+    for (const stmt of sf.statements) {
+        if (!typescript_1.default.isClassDeclaration(stmt))
+            continue;
+        // Determine if the class is exported
+        const hasExportModifier = stmt.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+        const className = stmt.name?.text;
+        const isExported = hasExportModifier ||
+            (className !== undefined && reExportedNames.has(className)) ||
+            (className !== undefined && defaultExportedNames.has(className));
+        if (!isExported)
+            continue;
+        const sleepMethods = [];
+        for (const member of stmt.members) {
+            if (!typescript_1.default.isMethodDeclaration(member))
+                continue;
+            if (!member.body)
+                continue;
+            if (!member.name || !typescript_1.default.isIdentifier(member.name))
+                continue;
+            if (bodyHasRetryLoop(member.body, sf))
+                continue;
+            if (bodyContainsSleepPattern(member.body)) {
+                sleepMethods.push(member.name.text);
+            }
+        }
+        if (sleepMethods.length > 0) {
+            results.push({
+                className: className ?? "default",
+                methodNames: sleepMethods,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Given a test file and a map of wrapper binding names → import paths,
+ * find call sites of those wrappers. Returns line numbers and function names.
+ */
+function findDisguisedHardWaitCalls(filePath, content, wrapperBindings, sleepMethodBindings) {
+    if (wrapperBindings.size === 0 && (!sleepMethodBindings || sleepMethodBindings.size === 0))
+        return [];
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            // Direct function call: delay(2000)
+            if (typescript_1.default.isIdentifier(node.expression)) {
+                const name = node.expression.text;
+                const importPath = wrapperBindings.get(name);
+                if (importPath) {
+                    results.push({
+                        file: filePath,
+                        line: lineOf(sf, node.getStart()),
+                        calledFunction: name,
+                        importPath,
+                    });
+                }
+            }
+            // Property access call: instance.delay(2000) or this.delay(2000)
+            if (sleepMethodBindings &&
+                sleepMethodBindings.size > 0 &&
+                typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                const methodName = node.expression.name.text;
+                const importPath = sleepMethodBindings.get(methodName);
+                if (importPath) {
+                    results.push({
+                        file: filePath,
+                        line: lineOf(sf, node.getStart()),
+                        calledFunction: methodName,
+                        importPath,
+                    });
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(sf);
+    return results;
+}
+// ─── PW-FLAKE-010: Retrieval Methods Without Content Guard ────────────
+const RETRIEVAL_METHODS = new Set([
+    "innerText", "textContent", "allInnerTexts",
+    "allTextContents", "innerHTML", "inputValue",
+]);
+const CONTENT_GUARD_MATCHERS = new Set([
+    "toHaveText", "toContainText", "toBeEmpty", "toBeVisible",
+]);
+/**
+ * Check whether a CallExpression is a content-guard assertion.
+ *
+ * Content guards are:
+ * 1. `expect()` chains whose final matcher is one of `toHaveText`,
+ *    `toContainText`, `toBeEmpty`, `toBeVisible`, or `toPass` — including
+ *    negated forms (`.not.toHaveText(...)`) and `.resolves`/`.rejects`.
+ * 2. Direct `locator.waitFor()` calls — these wait for the element to reach
+ *    an actionable state (default: "visible"), ensuring content is ready.
+ */
+function isContentGuard(node) {
+    if (!typescript_1.default.isCallExpression(node))
+        return false;
+    const methodName = getFinalMethodName(node);
+    if (!methodName)
+        return false;
+    // locator.waitFor() is a guard (waits for "visible" state by default)
+    if (methodName === "waitFor") {
+        // Accept if it's NOT inside an expect() chain — i.e. it's a direct locator call
+        const kind = getExpectChainKind(node);
+        if (kind === undefined)
+            return true;
+    }
+    // toPass() is a guard regardless of chain root
+    if (methodName === "toPass") {
+        const kind = getExpectChainKind(node);
+        return kind !== undefined;
+    }
+    if (!CONTENT_GUARD_MATCHERS.has(methodName))
+        return false;
+    const kind = getExpectChainKind(node);
+    return kind !== undefined;
+}
+/**
+ * Check if a CallExpression is a retrieval method call: `.innerText()`, etc.
+ * Returns the method name if matched, undefined otherwise.
+ */
+function getRetrievalMethodName(node) {
+    if (!typescript_1.default.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const name = node.expression.name.text;
+    return RETRIEVAL_METHODS.has(name) ? name : undefined;
+}
+/**
+ * Detect retrieval method calls (innerText, textContent, innerHTML, etc.)
+ * that are NOT preceded by a content guard within the same test body.
+ *
+ * A content guard is an expect() assertion with toHaveText, toContainText,
+ * toBeEmpty, or toPass that targets the same locator (or any locator within
+ * the preceding statements). The AST approach lets us check the actual
+ * statement ordering within the test callback body rather than relying on
+ * a fragile line-window regex heuristic.
+ */
+function findUnguardedRetrievalMethods(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        if (!typescript_1.default.isCallExpression(node)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Match test(...), test.only(...), test.slow(...)
+        const isTestCall = isCallTo(node, "test") || isMethodCall(node, "test", "only") ||
+            isMethodCall(node, "test", "slow");
+        if (!isTestCall) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Skip hooks and describe
+        if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+            const method = node.expression.name.text;
+            if (method === "beforeAll" || method === "afterAll" ||
+                method === "beforeEach" || method === "afterEach" ||
+                method === "describe") {
+                typescript_1.default.forEachChild(node, visit);
+                return;
+            }
+        }
+        // Extract test name
+        let testName = "(unnamed)";
+        if (node.arguments.length > 0 && typescript_1.default.isStringLiteral(node.arguments[0])) {
+            testName = node.arguments[0].text;
+        }
+        // Find the callback
+        let callback;
+        for (const arg of node.arguments) {
+            if (typescript_1.default.isArrowFunction(arg) || typescript_1.default.isFunctionExpression(arg)) {
+                callback = arg;
+            }
+        }
+        if (!callback || !callback.body || !typescript_1.default.isBlock(callback.body)) {
+            typescript_1.default.forEachChild(node, visit);
+            return;
+        }
+        // Collect statements in order; track which statements contain content guards
+        const stmts = callback.body.statements;
+        const guardSeen = new Set(); // statement indices that contain guards
+        // First pass: identify which statements contain content guards
+        for (let i = 0; i < stmts.length; i++) {
+            if (stmtContainsContentGuard(stmts[i])) {
+                guardSeen.add(i);
+            }
+        }
+        // Second pass: find retrieval method calls and check for preceding guards
+        for (let i = 0; i < stmts.length; i++) {
+            collectRetrievalCalls(stmts[i], sf).forEach((call) => {
+                // Check if any of the preceding statements (within 5 statements) is a guard
+                const windowStart = Math.max(0, i - 5);
+                let guarded = false;
+                for (let j = windowStart; j < i; j++) {
+                    if (guardSeen.has(j)) {
+                        guarded = true;
+                        break;
+                    }
+                }
+                // If the statement itself contains a guard, treat the retrieval as guarded
+                if (guardSeen.has(i))
+                    guarded = true;
+                if (!guarded) {
+                    results.push({
+                        file: filePath,
+                        line: call.line,
+                        testName,
+                        snippet: `.${call.method}()`,
+                    });
+                }
+            });
+        }
+    }
+    visit(sf);
+    return results;
+}
+/**
+ * Scan non-test files (POMs, page classes, fixtures) for retrieval method
+ * calls without a preceding content guard in the same function body.
+ *
+ * Walks every function, method, and arrow-function body in the file.
+ * Uses the same 5-statement guard window as the test-scoped variant.
+ */
+function findUnguardedRetrievalMethodsInFunctions(filePath, content) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        // Skip arrow/function expressions that are arguments to expect() chains —
+        // these are assertion/polling callbacks where retrieval is intentional.
+        if ((typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node)) &&
+            typescript_1.default.isCallExpression(node.parent)) {
+            const parentCall = node.parent;
+            // Direct expect(..., callback) or expect.poll(callback)
+            const chainKind = getExpectChainKind(parentCall);
+            if (chainKind !== undefined)
+                return;
+            // Callback is an argument to expect() itself: expect(async () => { ... })
+            if (typescript_1.default.isIdentifier(parentCall.expression) &&
+                parentCall.expression.text === "expect")
+                return;
+        }
+        // Match any function-like body: methods, arrow functions, function declarations/expressions
+        let body;
+        let scopeName = "(anonymous)";
+        if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node)) {
+            body = node.body && typescript_1.default.isBlock(node.body) ? node.body : undefined;
+            scopeName = node.name?.text ?? "(anonymous)";
+        }
+        else if (typescript_1.default.isMethodDeclaration(node)) {
+            body = node.body && typescript_1.default.isBlock(node.body) ? node.body : undefined;
+            if (typescript_1.default.isIdentifier(node.name))
+                scopeName = node.name.text;
+            else if (typescript_1.default.isStringLiteral(node.name))
+                scopeName = node.name.text;
+        }
+        else if (typescript_1.default.isArrowFunction(node) && node.body && typescript_1.default.isBlock(node.body)) {
+            body = node.body;
+            // Try to get name from parent variable declaration
+            if (typescript_1.default.isVariableDeclaration(node.parent) && typescript_1.default.isIdentifier(node.parent.name)) {
+                scopeName = node.parent.name.text;
+            }
+        }
+        if (body) {
+            const stmts = body.statements;
+            const guardSeen = new Set();
+            for (let i = 0; i < stmts.length; i++) {
+                if (stmtContainsContentGuard(stmts[i])) {
+                    guardSeen.add(i);
+                }
+            }
+            for (let i = 0; i < stmts.length; i++) {
+                collectRetrievalCalls(stmts[i], sf).forEach((call) => {
+                    const windowStart = Math.max(0, i - 5);
+                    let guarded = false;
+                    for (let j = windowStart; j < i; j++) {
+                        if (guardSeen.has(j)) {
+                            guarded = true;
+                            break;
+                        }
+                    }
+                    if (guardSeen.has(i))
+                        guarded = true;
+                    if (!guarded) {
+                        results.push({
+                            file: filePath,
+                            line: call.line,
+                            testName: scopeName,
+                            snippet: `.${call.method}()`,
+                        });
+                    }
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(sf);
+    return results;
+}
+/** Check if any node within a statement subtree contains a content guard. */
+function stmtContainsContentGuard(node) {
+    if (isContentGuard(node))
+        return true;
+    let found = false;
+    function walk(n) {
+        if (found)
+            return;
+        if (isContentGuard(n)) {
+            found = true;
+            return;
+        }
+        typescript_1.default.forEachChild(n, walk);
+    }
+    typescript_1.default.forEachChild(node, walk);
+    return found;
+}
+/** Collect all retrieval method calls from a statement subtree.
+ *  Skips nested arrow/function expressions (callbacks) since those
+ *  run in a different execution context (e.g., expect.poll callbacks). */
+function collectRetrievalCalls(node, sf) {
+    const calls = [];
+    function walk(n) {
+        // Don't descend into nested callbacks — those are separate contexts
+        if (typescript_1.default.isArrowFunction(n) || typescript_1.default.isFunctionExpression(n))
+            return;
+        if (typescript_1.default.isCallExpression(n)) {
+            const method = getRetrievalMethodName(n);
+            if (method) {
+                calls.push({ line: lineOf(sf, n.getStart()), method });
+            }
+        }
+        typescript_1.default.forEachChild(n, walk);
+    }
+    walk(node);
+    return calls;
+}
+// ─── ARCH-002: AST-Based POM "Locator Bag" Detection ─────────────────
+/** Locator-related Playwright page method prefixes. */
+const LOCATOR_PAGE_METHODS = new Set([
+    "locator",
+    "getByRole",
+    "getByText",
+    "getByLabel",
+    "getByPlaceholder",
+    "getByAltText",
+    "getByTitle",
+    "getByTestId",
+]);
+function isLocatorInit(expr) {
+    // Matches: (this.)page.locator() / (this.)page.getBy*()
+    if (!typescript_1.default.isCallExpression(expr))
+        return false;
+    const callee = expr.expression;
+    if (!typescript_1.default.isPropertyAccessExpression(callee))
+        return false;
+    const methodName = callee.name.text;
+    if (!LOCATOR_PAGE_METHODS.has(methodName))
+        return false;
+    // The object should be `page` or `this.page`
+    const obj = callee.expression;
+    if (typescript_1.default.isIdentifier(obj) && obj.text === "page")
+        return true;
+    if (typescript_1.default.isPropertyAccessExpression(obj) &&
+        obj.name.text === "page" &&
+        obj.expression.kind === typescript_1.default.SyntaxKind.ThisKeyword)
+        return true;
+    return false;
+}
+function hasModifier(node, kind) {
+    const mods = typescript_1.default.canHaveModifiers(node) ? typescript_1.default.getModifiers(node) : undefined;
+    return mods?.some((m) => m.kind === kind) ?? false;
+}
+function isPrivateOrProtected(node) {
+    return (hasModifier(node, typescript_1.default.SyntaxKind.PrivateKeyword) ||
+        hasModifier(node, typescript_1.default.SyntaxKind.ProtectedKeyword));
+}
+/**
+ * Analyze a POM file's class structure to determine if it is a "locator bag":
+ * a class with many public locators and few/no action methods that use them.
+ *
+ * Returns null if the file does not contain a class declaration.
+ */
+function analyzePomClassStructure(filePath, content) {
+    const sf = parseSource(filePath, content);
+    // Find the first class declaration
+    let classDecl;
+    function findClass(node) {
+        if (classDecl)
+            return;
+        if (typescript_1.default.isClassDeclaration(node)) {
+            classDecl = node;
+            return;
+        }
+        typescript_1.default.forEachChild(node, findClass);
+    }
+    findClass(sf);
+    if (!classDecl)
+        return null;
+    const className = classDecl.name?.text ?? "(anonymous)";
+    let extendsClass = null;
+    if (classDecl.heritageClauses) {
+        for (const clause of classDecl.heritageClauses) {
+            if (clause.token === typescript_1.default.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+                const baseExpr = clause.types[0].expression;
+                if (typescript_1.default.isIdentifier(baseExpr)) {
+                    extendsClass = baseExpr.text;
+                }
+            }
+        }
+    }
+    // Phase 1: Discover public locator properties
+    const locatorNames = [];
+    // Map property names to their declarations for modifier checking
+    const propertyDecls = new Map();
+    for (const member of classDecl.members) {
+        if (typescript_1.default.isPropertyDeclaration(member) && typescript_1.default.isIdentifier(member.name)) {
+            propertyDecls.set(member.name.text, member);
+        }
+    }
+    // 1a: Property declarations with locator initializers
+    for (const member of classDecl.members) {
+        if (typescript_1.default.isPropertyDeclaration(member) && typescript_1.default.isIdentifier(member.name)) {
+            if (isPrivateOrProtected(member))
+                continue;
+            if (member.initializer && isLocatorInit(member.initializer)) {
+                locatorNames.push(member.name.text);
+            }
+        }
+    }
+    // 1b: Constructor-assigned locators: this.foo = (this.)page.locator/getBy*()
+    for (const member of classDecl.members) {
+        if (!typescript_1.default.isConstructorDeclaration(member) || !member.body)
+            continue;
+        for (const stmt of member.body.statements) {
+            if (!typescript_1.default.isExpressionStatement(stmt))
+                continue;
+            const expr = stmt.expression;
+            if (!typescript_1.default.isBinaryExpression(expr) || expr.operatorToken.kind !== typescript_1.default.SyntaxKind.EqualsToken)
+                continue;
+            // LHS: this.foo
+            const lhs = expr.left;
+            if (!typescript_1.default.isPropertyAccessExpression(lhs) ||
+                lhs.expression.kind !== typescript_1.default.SyntaxKind.ThisKeyword ||
+                !typescript_1.default.isIdentifier(lhs.name))
+                continue;
+            const propName = lhs.name.text;
+            // Skip if already found via property declaration
+            if (locatorNames.includes(propName))
+                continue;
+            // Check the RHS is a locator init
+            if (!isLocatorInit(expr.right))
+                continue;
+            // Check if the property declaration has private/protected
+            const propDecl = propertyDecls.get(propName);
+            if (propDecl && isPrivateOrProtected(propDecl))
+                continue;
+            locatorNames.push(propName);
+        }
+    }
+    const publicLocatorCount = locatorNames.length;
+    const locatorNameSet = new Set(locatorNames);
+    // Phase 2: Count action methods that reference locators via this.<locatorName>
+    const actionMethodNames = [];
+    let totalMethodCount = 0;
+    for (const member of classDecl.members) {
+        // Skip getters and setters — they're separate AST node types
+        if (typescript_1.default.isGetAccessorDeclaration(member))
+            continue;
+        if (typescript_1.default.isSetAccessorDeclaration(member))
+            continue;
+        if (!typescript_1.default.isMethodDeclaration(member))
+            continue;
+        if (!typescript_1.default.isIdentifier(member.name))
+            continue;
+        // Skip constructor (already handled above; methods only)
+        const methodName = member.name.text;
+        if (methodName === "constructor")
+            continue;
+        totalMethodCount++;
+        // Check if method body references this.<locatorName>
+        if (!member.body)
+            continue;
+        let referencesLocator = false;
+        function checkLocatorRef(node) {
+            if (referencesLocator)
+                return;
+            if (typescript_1.default.isPropertyAccessExpression(node) &&
+                node.expression.kind === typescript_1.default.SyntaxKind.ThisKeyword &&
+                typescript_1.default.isIdentifier(node.name) &&
+                locatorNameSet.has(node.name.text)) {
+                referencesLocator = true;
+                return;
+            }
+            typescript_1.default.forEachChild(node, checkLocatorRef);
+        }
+        checkLocatorRef(member.body);
+        if (referencesLocator) {
+            actionMethodNames.push(methodName);
+        }
+    }
+    const actionMethodCount = actionMethodNames.length;
+    // A POM is a "locator bag" when it has many public locators
+    // and fewer than 30% of them have wrapping action methods.
+    const isLocatorBag = publicLocatorCount > 5 &&
+        (publicLocatorCount === 0 || actionMethodCount / publicLocatorCount < 0.3);
+    return {
+        className,
+        extendsClass,
+        publicLocatorCount,
+        locatorNames,
+        actionMethodCount,
+        actionMethodNames,
+        totalMethodCount,
+        isLocatorBag,
+    };
+}
+// ─── ARCH-008: Large Inline Data Literals ────────────────────────────
+/**
+ * Check whether an ObjectLiteralExpression or ArrayLiteralExpression is
+ * "data-like": mostly primitives / nested object-arrays, no function or
+ * class values. Returns false if any element is an arrow function,
+ * function expression, or class expression.
+ */
+function isDataLike(node) {
+    const children = typescript_1.default.isObjectLiteralExpression(node)
+        ? node.properties
+        : node.elements;
+    for (const child of children) {
+        if (typescript_1.default.isArrowFunction(child) || typescript_1.default.isFunctionExpression(child) || typescript_1.default.isClassExpression(child)) {
+            return false;
+        }
+        if (typescript_1.default.isPropertyAssignment(child)) {
+            const init = child.initializer;
+            if (typescript_1.default.isArrowFunction(init) || typescript_1.default.isFunctionExpression(init) || typescript_1.default.isClassExpression(init)) {
+                return false;
+            }
+        }
+        if (typescript_1.default.isSpreadAssignment(child) || typescript_1.default.isSpreadElement(child)) {
+            // Spread from an import (e.g. ...basePayload) is fine — skip deep check
+            continue;
+        }
+    }
+    return true;
+}
+/**
+ * Infer a symbol name for the variable/property that holds the literal.
+ * Walks up through parents: VariableDeclaration → name, PropertyAssignment → name,
+ * ExportAssignment → "default", otherwise "(anonymous)".
+ */
+function inferSymbolName(node) {
+    const parent = node.parent;
+    if (!parent)
+        return "(anonymous)";
+    if (typescript_1.default.isVariableDeclaration(parent) && typescript_1.default.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    if (typescript_1.default.isPropertyAssignment(parent) && typescript_1.default.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    if (typescript_1.default.isPropertyAssignment(parent) && typescript_1.default.isStringLiteral(parent.name)) {
+        return parent.name.text;
+    }
+    if (typescript_1.default.isExportAssignment(parent)) {
+        return "default";
+    }
+    // `as const` satisfies: unwrap one level
+    if (typescript_1.default.isAsExpression(parent) || typescript_1.default.isSatisfiesExpression(parent)) {
+        return inferSymbolName(parent);
+    }
+    return "(anonymous)";
+}
+/**
+ * Find large inline object/array literals (≥ threshold lines) in a source file.
+ * Only counts ObjectLiteralExpression and ArrayLiteralExpression nodes that are
+ * data-like (no function values). Ignores function bodies, class bodies, type
+ * declarations, and import/export blocks.
+ */
+function findLargeInlineDataLiterals(filePath, content, threshold = 50) {
+    const sf = parseSource(filePath, content);
+    const results = [];
+    function visit(node) {
+        // Only inspect object and array literal expressions
+        if ((typescript_1.default.isObjectLiteralExpression(node) || typescript_1.default.isArrayLiteralExpression(node)) &&
+            isDataLike(node)) {
+            const startLine = lineOf(sf, node.getStart());
+            const endLine = lineOf(sf, node.getEnd());
+            const lineCount = endLine - startLine + 1;
+            if (lineCount >= threshold) {
+                results.push({
+                    file: filePath,
+                    line: startLine,
+                    endLine,
+                    lineCount,
+                    symbolName: inferSymbolName(node),
+                    nodeType: typescript_1.default.isObjectLiteralExpression(node) ? "object" : "array",
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(sf);
+    return results;
+}