@autotests/playwright-impact 0.1.0

package/src/modules/file-and-git-helpers.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { runCommand } = require('./shell');
+
+const STATUS_PRIORITY = { D: 4, R: 3, M: 2, A: 1 };
+const SUPPORTED_FILE_EXTENSIONS = new Set(['.ts', '.tsx']);
+
+const readFileFromBaseRef = ({ repoRoot, relativePath, baseRef }) => {
+  if (!relativePath) return null;
+  const effectiveBaseRef = String(baseRef || 'HEAD').trim();
+  if (!effectiveBaseRef) return null;
+  const showResult = runCommand('git', ['show', `${effectiveBaseRef}:${relativePath}`], { cwd: repoRoot });
+  if (showResult.status !== 0 || showResult.error) return null;
+  return typeof showResult.stdout === 'string' ? showResult.stdout : null;
+};
+
+const readFileFromWorkingTree = ({ repoRoot, relativePath }) => {
+  if (!relativePath) return null;
+  const absolutePath = path.join(repoRoot, relativePath);
+  if (!fs.existsSync(absolutePath)) return null;
+  return fs.readFileSync(absolutePath, 'utf8');
+};
+
+const parseChangedEntryLine = (line) => {
+  const parts = line.split('\t').filter(Boolean);
+  if (parts.length < 2) return null;
+
+  const rawStatus = String(parts[0] || '').trim().toUpperCase();
+  if (!rawStatus) return null;
+
+  if (rawStatus.startsWith('R') || rawStatus.startsWith('C')) {
+    const oldPath = String(parts[1] || '').trim();
+    const newPath = String(parts[2] || '').trim();
+    if (!oldPath || !newPath) return null;
+    return {
+      status: rawStatus.startsWith('R') ? 'R' : 'C',
+      oldPath,
+      newPath,
+      effectivePath: newPath,
+      rawStatus,
+    };
+  }
+
+  const shortStatus = rawStatus[0];
+  const targetPath = String(parts[1] || '').trim();
+  if (!targetPath) return null;
+
+  return {
+    status: shortStatus,
+    oldPath: shortStatus === 'A' ? null : targetPath,
+    newPath: shortStatus === 'D' ? null : targetPath,
+    effectivePath: targetPath,
+    rawStatus,
+  };
+};
+
+const listFilesRecursive = (rootDir) => {
+  if (!fs.existsSync(rootDir)) return [];
+  const files = [];
+  const stack = [rootDir];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const nextPath = path.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(nextPath);
+      else files.push(nextPath);
+    }
+  }
+
+  return files;
+};
+
+const runDiffAndParse = ({ repoRoot, args }) => {
+  // Use rename detection to keep semantic compare stable across pure file moves/renames.
+  const result = runCommand('git', ['diff', '--name-status', '-M', ...args], { cwd: repoRoot });
+  if (result.error) throw new Error(`Failed to execute git diff: ${result.error.message}`);
+  if (result.status !== 0) {
+    const details = (result.stderr || result.stdout || '').trim();
+    throw new Error(`git diff failed with code ${result.status}: ${details}`);
+  }
+
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map(parseChangedEntryLine)
+    .filter((entry) => Boolean(entry));
+};
+
+const normalizeEntryStatus = (entry, warnings) => {
+  // Compatibility fallback:
+  // - C behaves like an add because there is no stable base path identity
+  // - T/U/unknown behave like modify to preserve fail-open behavior
+  const status = String(entry.status || '').toUpperCase();
+  if (['A', 'M', 'D', 'R'].includes(status)) return { ...entry, status };
+
+  if (status === 'C') {
+    warnings.push(`Status fallback: ${entry.rawStatus || 'C'} mapped to A for ${entry.effectivePath}`);
+    return { ...entry, status: 'A', oldPath: null };
+  }
+
+  if (status === 'T' || status === 'U') {
+    warnings.push(`Status fallback: ${entry.rawStatus || status} mapped to M for ${entry.effectivePath}`);
+    return { ...entry, status: 'M', oldPath: entry.oldPath || entry.effectivePath, newPath: entry.newPath || entry.effectivePath };
+  }
+
+  warnings.push(`Status fallback: ${entry.rawStatus || status || 'unknown'} mapped to M for ${entry.effectivePath}`);
+  return { ...entry, status: 'M', oldPath: entry.oldPath || entry.effectivePath, newPath: entry.newPath || entry.effectivePath };
+};
+
+const mergeByPriority = (existing, incoming) => {
+  if (!existing) return incoming;
+  const currentPriority = STATUS_PRIORITY[existing.status] || 0;
+  const incomingPriority = STATUS_PRIORITY[incoming.status] || 0;
+  if (incomingPriority > currentPriority) return incoming;
+  if (incomingPriority < currentPriority) return existing;
+
+  // If priorities are equal, keep entry with richer rename info.
+  if (incoming.status === 'R' && incoming.oldPath && incoming.newPath) return incoming;
+  return existing;
+};
+
+const isValidExtension = (filePath, fileExtensions) => {
+  const ext = path.extname(filePath);
+  return fileExtensions.includes(ext);
+};
+
+const getUntrackedPaths = ({ repoRoot }) => {
+  const result = runCommand('git', ['ls-files', '--others', '--exclude-standard'], { cwd: repoRoot });
+  if (result.error || result.status !== 0) return [];
+
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .sort((a, b) => a.localeCompare(b));
+};
+
+const getUntrackedSpecPaths = ({ repoRoot, changedSpecPrefix, fileExtensions = ['.ts', '.tsx'] }) => {
+  return getUntrackedPaths({ repoRoot })
+    .filter((filePath) => filePath.startsWith(changedSpecPrefix))
+    .filter((filePath) => fileExtensions.some((ext) => filePath.endsWith(`.spec${ext}`)));
+};
+
+const getUntrackedSourceEntries = ({ repoRoot, profile, fileExtensions = ['.ts', '.tsx'] }) => {
+  return getUntrackedPaths({ repoRoot })
+    .filter((filePath) => isValidExtension(filePath, fileExtensions))
+    .filter((filePath) => profile.isRelevantPomPath(filePath))
+    .map((filePath) => ({
+      status: 'A',
+      oldPath: null,
+      newPath: filePath,
+      effectivePath: filePath,
+      rawStatus: 'A (untracked source)',
+    }));
+};
+
+/**
+ * Build normalized changed entries for analysis.
+ * Sources:
+ * - git diff <base>...HEAD (if baseRef is set)
+ * - git diff HEAD (working tree, optionally merged with base mode)
+ * - untracked source files matching profile.isRelevantPomPath
+ */
+const getChangedEntries = ({ repoRoot, baseRef, includeWorkingTreeWithBase = true, profile = null, fileExtensions = ['.ts', '.tsx'] }) => {
+  const warnings = [];
+  let statusFallbackHits = 0;
+
+  const baseHeadEntries = baseRef ? runDiffAndParse({ repoRoot, args: [`${baseRef}...HEAD`] }) : [];
+  const workingTreeEntries = (!baseRef || includeWorkingTreeWithBase) ? runDiffAndParse({ repoRoot, args: ['HEAD'] }) : [];
+  const combined = [...baseHeadEntries, ...workingTreeEntries];
+
+  if (!baseRef && combined.length === 0) {
+    // Keep backward-compatible behavior for local-only mode where `HEAD` diff is the primary source.
+    combined.push(...workingTreeEntries);
+  }
+
+  if (profile && typeof profile.isRelevantPomPath === 'function') {
+    combined.push(...getUntrackedSourceEntries({ repoRoot, profile, fileExtensions }));
+  }
+
+  // Deterministic status merge by effective path with explicit precedence (D > R > M > A).
+  const mergedByPath = new Map();
+  for (const entry of combined) {
+    const normalized = normalizeEntryStatus(entry, warnings);
+    if (!['A', 'M', 'D', 'R'].includes(normalized.status)) continue;
+    if (normalized.status !== entry.status) statusFallbackHits += 1;
+
+    const key = normalized.effectivePath;
+    const existing = mergedByPath.get(key);
+    mergedByPath.set(key, mergeByPriority(existing, normalized));
+  }
+
+  const entries = Array.from(mergedByPath.values()).sort((a, b) => a.effectivePath.localeCompare(b.effectivePath));
+
+  return {
+    entries,
+    warnings,
+    statusFallbackHits,
+    changedEntriesBySource: {
+      fromBaseHead: baseHeadEntries.length,
+      fromWorkingTree: workingTreeEntries.length,
+      fromUntracked: profile ? getUntrackedSourceEntries({ repoRoot, profile, fileExtensions }).length : 0,
+    },
+  };
+};
+
+const readChangeContents = ({ repoRoot, entry, baseRef }) => {
+  const basePath = entry?.status === 'R' ? entry.oldPath : entry?.oldPath;
+  const headPath = entry?.status === 'R' ? entry.newPath : entry?.newPath;
+
+  const baseContent = basePath ? readFileFromBaseRef({ repoRoot, relativePath: basePath, baseRef }) : null;
+  const headContent = headPath ? readFileFromWorkingTree({ repoRoot, relativePath: headPath }) : null;
+
+  return { basePath: basePath || null, headPath: headPath || null, baseContent, headContent };
+};
+
+module.exports = {
+  SUPPORTED_FILE_EXTENSIONS,
+  listFilesRecursive,
+  getChangedEntries,
+  readChangeContents,
+  getUntrackedSpecPaths,
+  getUntrackedSourceEntries,
+  __testOnly: {
+    parseChangedEntryLine,
+    normalizeEntryStatus,
+    mergeByPriority,
+  },
+};

package/src/modules/fixture-map-helpers.js

@@ -0,0 +1,167 @@
+'use strict';
+
+const fs = require('fs');
+const ts = require('typescript');
+
+/**
+ * Parse fixture declarations from fixture types file.
+ * Supported shapes include direct types, namespace-qualified types,
+ * interfaces, and type intersections.
+ */
+const parseFixtureClassMap = ({ typesPath }) => {
+  if (!typesPath || !fs.existsSync(typesPath)) return new Map();
+  const content = fs.readFileSync(typesPath, 'utf8');
+  const classToFixtureKeys = new Map();
+  const sourceFile = ts.createSourceFile(typesPath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const declarationsByName = new Map();
+  const memoByDeclarationName = new Map();
+
+  const addMapping = (fixtureKey, className) => {
+    if (!fixtureKey || !className) return;
+    if (!classToFixtureKeys.has(className)) classToFixtureKeys.set(className, new Set());
+    classToFixtureKeys.get(className).add(fixtureKey);
+  };
+
+  const getDeclarationName = (node) => {
+    if (!node || !node.name || !ts.isIdentifier(node.name)) return null;
+    return node.name.text;
+  };
+
+  const getEntityRightmostName = (entity) => {
+    if (!entity) return null;
+    if (ts.isIdentifier(entity)) return entity.text;
+    if (ts.isQualifiedName(entity)) return entity.right.text;
+    return null;
+  };
+
+  const getExpressionRightmostName = (expression) => {
+    if (!expression) return null;
+    if (ts.isIdentifier(expression)) return expression.text;
+    if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+    return null;
+  };
+
+  const getPropertyNameText = (nameNode) => {
+    if (!nameNode) return null;
+    if (ts.isIdentifier(nameNode)) return nameNode.text;
+    if (ts.isStringLiteral(nameNode) || ts.isNoSubstitutionTemplateLiteral(nameNode)) return nameNode.text;
+    return null;
+  };
+
+  const getTypeReferenceName = (typeNode) => {
+    if (!typeNode || !ts.isTypeReferenceNode(typeNode)) return null;
+    return getEntityRightmostName(typeNode.typeName);
+  };
+
+  const isClassLikeTypeName = (typeName) => Boolean(typeName) && /^[A-Z]/.test(typeName);
+
+  const collectPairsFromTypeNode = (typeNode, visitingNames) => {
+    if (!typeNode) return [];
+
+    if (ts.isTypeLiteralNode(typeNode)) {
+      const pairs = [];
+      for (const member of typeNode.members) {
+        if (!ts.isPropertySignature(member) || !member.type) continue;
+        const fixtureKey = getPropertyNameText(member.name);
+        const className = getTypeReferenceName(member.type);
+        if (fixtureKey && isClassLikeTypeName(className)) {
+          pairs.push([fixtureKey, className]);
+        }
+      }
+      return pairs;
+    }
+
+    if (ts.isIntersectionTypeNode(typeNode) || ts.isUnionTypeNode(typeNode)) {
+      return typeNode.types.flatMap((child) => collectPairsFromTypeNode(child, visitingNames));
+    }
+
+    if (ts.isParenthesizedTypeNode(typeNode)) {
+      return collectPairsFromTypeNode(typeNode.type, visitingNames);
+    }
+
+    if (ts.isTypeReferenceNode(typeNode)) {
+      const refName = getEntityRightmostName(typeNode.typeName);
+      if (!refName) return [];
+      return collectPairsFromDeclarationName(refName, visitingNames);
+    }
+
+    return [];
+  };
+
+  const collectPairsFromInterface = (declaration, visitingNames) => {
+    const pairs = [];
+    for (const member of declaration.members) {
+      if (!ts.isPropertySignature(member) || !member.type) continue;
+      const fixtureKey = getPropertyNameText(member.name);
+      const className = getTypeReferenceName(member.type);
+      if (fixtureKey && isClassLikeTypeName(className)) pairs.push([fixtureKey, className]);
+      if (member.type) pairs.push(...collectPairsFromTypeNode(member.type, visitingNames));
+    }
+
+    for (const heritageClause of declaration.heritageClauses || []) {
+      if (heritageClause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+      for (const heritageType of heritageClause.types) {
+        const baseName = getExpressionRightmostName(heritageType.expression);
+        if (!baseName) continue;
+        pairs.push(...collectPairsFromDeclarationName(baseName, visitingNames));
+      }
+    }
+
+    return pairs;
+  };
+
+  const collectPairsFromDeclarationName = (declarationName, visitingNames) => {
+    if (!declarationName) return [];
+    if (memoByDeclarationName.has(declarationName)) return memoByDeclarationName.get(declarationName);
+    if (visitingNames.has(declarationName)) return [];
+
+    visitingNames.add(declarationName);
+    const declaration = declarationsByName.get(declarationName);
+    if (!declaration) {
+      visitingNames.delete(declarationName);
+      memoByDeclarationName.set(declarationName, []);
+      return [];
+    }
+
+    let pairs = [];
+    if (ts.isTypeAliasDeclaration(declaration)) {
+      pairs = collectPairsFromTypeNode(declaration.type, visitingNames);
+    } else if (ts.isInterfaceDeclaration(declaration)) {
+      pairs = collectPairsFromInterface(declaration, visitingNames);
+    }
+
+    visitingNames.delete(declarationName);
+    memoByDeclarationName.set(declarationName, pairs);
+    return pairs;
+  };
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isTypeAliasDeclaration(statement) && !ts.isInterfaceDeclaration(statement)) continue;
+    const declarationName = getDeclarationName(statement);
+    if (!declarationName) continue;
+    declarationsByName.set(declarationName, statement);
+  }
+
+  for (const declarationName of declarationsByName.keys()) {
+    const pairs = collectPairsFromDeclarationName(declarationName, new Set());
+    for (const [fixtureKey, className] of pairs) addMapping(fixtureKey, className);
+  }
+
+  return classToFixtureKeys;
+};
+
+/**
+ * Return bidirectional fixture mappings used by Stage A and Stage B.
+ */
+const parseFixtureMappings = ({ typesPath }) => {
+  const classToFixtureKeys = parseFixtureClassMap({ typesPath });
+  const fixtureKeyToClass = new Map();
+  for (const [className, fixtureKeys] of classToFixtureKeys.entries()) {
+    for (const fixtureKey of fixtureKeys) fixtureKeyToClass.set(fixtureKey, className);
+  }
+  return { classToFixtureKeys, fixtureKeyToClass };
+};
+
+module.exports = {
+  parseFixtureMappings,
+};

package/src/modules/global-watch-helpers.js

@@ -0,0 +1,278 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+const DEFAULT_GLOBAL_WATCH_PATTERNS = [
+  'playwright.stem.config.ts',
+  'playwright.mn.config.ts',
+  'playwright.e2e.config.ts',
+  'src/global-setup.ts',
+  'src/global-setup-stem.ts',
+  'src/global-setup-mn.ts',
+  'src/fixtures/**',
+  'src/setup/**',
+  'src/config/config.ts',
+  'src/config/urls.ts',
+  'src/reporters/**',
+  'src/scripts/verify-*.js',
+  'src/api/mocks/**',
+];
+
+const WATCH_DEP_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.yml', '.yaml'];
+
+const normalizePath = (filePath) => String(filePath || '').replace(/\\/g, '/');
+
+const globToRegex = (globPattern) => {
+  const normalized = normalizePath(globPattern).replace(/^\.\//, '');
+  let regex = '^';
+  for (let index = 0; index < normalized.length; index += 1) {
+    const char = normalized[index];
+    const next = normalized[index + 1];
+    if (char === '*' && next === '*') {
+      regex += '.*';
+      index += 1;
+      continue;
+    }
+    if (char === '*') {
+      regex += '[^/]*';
+      continue;
+    }
+    if ('\\^$+?.()|{}[]'.includes(char)) {
+      regex += `\\${char}`;
+      continue;
+    }
+    regex += char;
+  }
+  regex += '$';
+  return new RegExp(regex);
+};
+
+const getDefaultGlobalWatchPatterns = () => [...DEFAULT_GLOBAL_WATCH_PATTERNS];
+
+const getCandidateFilePaths = (basePath) => {
+  const ext = path.extname(basePath).toLowerCase();
+  if (WATCH_DEP_EXTENSIONS.includes(ext)) return [basePath];
+
+  const candidates = [];
+  candidates.push(...WATCH_DEP_EXTENSIONS.map((fileExt) => `${basePath}${fileExt}`));
+  candidates.push(...WATCH_DEP_EXTENSIONS.map((fileExt) => path.join(basePath, `index${fileExt}`)));
+  return candidates;
+};
+
+const readTsConfigPathAliases = (repoRoot) => {
+  const tsConfigPath = path.join(repoRoot, 'tsconfig.json');
+  if (!fs.existsSync(tsConfigPath)) return [];
+
+  const rawText = fs.readFileSync(tsConfigPath, 'utf8');
+  const parsedResult = ts.parseConfigFileTextToJson(tsConfigPath, rawText);
+  const parsed = parsedResult?.config;
+  if (!parsed || typeof parsed !== 'object') return [];
+
+  const baseUrl = parsed?.compilerOptions?.baseUrl || '.';
+  const paths = parsed?.compilerOptions?.paths || {};
+  const entries = [];
+
+  for (const [aliasPattern, targets] of Object.entries(paths)) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const hasWildcard = aliasPattern.includes('*');
+    const [aliasPrefix, aliasSuffix] = hasWildcard ? aliasPattern.split('*') : [aliasPattern, ''];
+
+    entries.push({
+      aliasPattern,
+      aliasPrefix,
+      aliasSuffix,
+      hasWildcard,
+      targets: targets.map((targetPattern) => {
+        const [targetPrefix, targetSuffix] = targetPattern.includes('*') ? targetPattern.split('*') : [targetPattern, ''];
+        return { targetPrefix, targetSuffix };
+      }),
+      baseUrlAbs: path.resolve(repoRoot, baseUrl),
+    });
+  }
+
+  return entries;
+};
+
+const resolveModuleSpecifier = ({ importerAbsPath, moduleSpecifier, repoRoot, aliasEntries }) => {
+  const resolved = [];
+
+  const addResolvedFromBase = (basePathAbs) => {
+    for (const candidate of getCandidateFilePaths(basePathAbs)) {
+      if (!fs.existsSync(candidate)) continue;
+      resolved.push(path.resolve(candidate));
+    }
+  };
+
+  if (moduleSpecifier.startsWith('.')) {
+    addResolvedFromBase(path.resolve(path.dirname(importerAbsPath), moduleSpecifier));
+    return Array.from(new Set(resolved));
+  }
+
+  const looksLikeFileName = /\.[A-Za-z0-9]+$/.test(moduleSpecifier);
+  if (looksLikeFileName) {
+    let currentDir = path.dirname(importerAbsPath);
+    const repoRootAbs = path.resolve(repoRoot);
+    while (currentDir.startsWith(repoRootAbs)) {
+      const candidate = path.resolve(currentDir, moduleSpecifier);
+      if (fs.existsSync(candidate)) resolved.push(candidate);
+      if (currentDir === repoRootAbs) break;
+      currentDir = path.dirname(currentDir);
+    }
+  }
+
+  for (const alias of aliasEntries) {
+    if (!alias.hasWildcard) {
+      if (moduleSpecifier !== alias.aliasPattern) continue;
+      for (const target of alias.targets) addResolvedFromBase(path.resolve(alias.baseUrlAbs, target.targetPrefix));
+      continue;
+    }
+
+    if (!moduleSpecifier.startsWith(alias.aliasPrefix) || !moduleSpecifier.endsWith(alias.aliasSuffix)) continue;
+    const wildcardValue = moduleSpecifier.slice(alias.aliasPrefix.length, moduleSpecifier.length - alias.aliasSuffix.length);
+    for (const target of alias.targets) {
+      const joined = `${target.targetPrefix}${wildcardValue}${target.targetSuffix}`;
+      addResolvedFromBase(path.resolve(alias.baseUrlAbs, joined));
+    }
+  }
+
+  return Array.from(new Set(resolved));
+};
+
+const extractImportSpecifiers = (sourceFile) => {
+  const specifiers = [];
+  const addText = (node) => {
+    if (node && ts.isStringLiteral(node)) specifiers.push(node.text);
+  };
+
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node)) addText(node.moduleSpecifier);
+    if (ts.isExportDeclaration(node) && node.moduleSpecifier) addText(node.moduleSpecifier);
+    if (ts.isCallExpression(node)) {
+      if (ts.isIdentifier(node.expression) && node.expression.text === 'require') addText(node.arguments?.[0]);
+      if (node.expression.kind === ts.SyntaxKind.ImportKeyword) addText(node.arguments?.[0]);
+      for (const argument of node.arguments || []) {
+        if (ts.isStringLiteral(argument) && /\.[A-Za-z0-9]+$/.test(argument.text)) specifiers.push(argument.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return specifiers;
+};
+
+const resolveWatchSeedFiles = ({ repoRoot, patterns, listFilesRecursive }) => {
+  const seedFiles = new Set();
+  for (const pattern of patterns) {
+    const normalizedPattern = normalizePath(pattern).replace(/^\.\//, '');
+    const hasWildcard = normalizedPattern.includes('*');
+    const absolute = path.resolve(repoRoot, normalizedPattern);
+    if (!hasWildcard) {
+      if (fs.existsSync(absolute) && fs.statSync(absolute).isFile()) seedFiles.add(absolute);
+      continue;
+    }
+
+    const regex = globToRegex(normalizedPattern);
+    const firstWildcardIndex = normalizedPattern.indexOf('*');
+    const fixedPrefix = firstWildcardIndex >= 0 ? normalizedPattern.slice(0, firstWildcardIndex) : normalizedPattern;
+    const prefixDir = fixedPrefix.includes('/') ? fixedPrefix.slice(0, fixedPrefix.lastIndexOf('/')) : '';
+    const scanRoot = path.resolve(repoRoot, prefixDir || '.');
+    if (!fs.existsSync(scanRoot)) continue;
+
+    const candidates = fs.statSync(scanRoot).isFile() ? [scanRoot] : listFilesRecursive(scanRoot);
+    for (const candidateAbs of candidates) {
+      if (!fs.existsSync(candidateAbs) || !fs.statSync(candidateAbs).isFile()) continue;
+      const relative = normalizePath(path.relative(repoRoot, candidateAbs));
+      if (regex.test(relative)) seedFiles.add(path.resolve(candidateAbs));
+    }
+  }
+  return seedFiles;
+};
+
+const resolveGlobalWatchClosure = ({ repoRoot, patterns, listFilesRecursive }) => {
+  const aliasEntries = readTsConfigPathAliases(repoRoot);
+  const seeds = resolveWatchSeedFiles({ repoRoot, patterns, listFilesRecursive });
+  const resolvedFiles = new Set(seeds);
+  const queue = Array.from(seeds);
+  const visited = new Set();
+
+  while (queue.length > 0) {
+    const currentAbs = path.resolve(queue.shift());
+    if (visited.has(currentAbs)) continue;
+    visited.add(currentAbs);
+    if (!fs.existsSync(currentAbs)) continue;
+
+    const ext = path.extname(currentAbs).toLowerCase();
+    if (!WATCH_DEP_EXTENSIONS.includes(ext) || ext === '.json' || ext === '.yml' || ext === '.yaml') continue;
+
+    let content;
+    try {
+      content = fs.readFileSync(currentAbs, 'utf8');
+    } catch (_error) {
+      continue;
+    }
+
+    const scriptKind = currentAbs.endsWith('.tsx')
+      ? ts.ScriptKind.TSX
+      : (currentAbs.endsWith('.js') || currentAbs.endsWith('.mjs') || currentAbs.endsWith('.cjs'))
+        ? ts.ScriptKind.JS
+        : ts.ScriptKind.TS;
+
+    const sourceFile = ts.createSourceFile(currentAbs, content, ts.ScriptTarget.Latest, true, scriptKind);
+    const importSpecifiers = extractImportSpecifiers(sourceFile);
+    for (const moduleSpecifier of importSpecifiers) {
+      const dependencies = resolveModuleSpecifier({ importerAbsPath: currentAbs, moduleSpecifier, repoRoot, aliasEntries });
+      for (const dependencyAbs of dependencies) {
+        if (!dependencyAbs.startsWith(path.resolve(repoRoot))) continue;
+        if (!resolvedFiles.has(dependencyAbs)) {
+          resolvedFiles.add(dependencyAbs);
+          queue.push(dependencyAbs);
+        }
+      }
+    }
+  }
+
+  return {
+    resolvedFilesAbs: resolvedFiles,
+    resolvedFilesRelative: Array.from(resolvedFiles).map((filePath) => normalizePath(path.relative(repoRoot, filePath))).sort((a, b) => a.localeCompare(b)),
+  };
+};
+
+const evaluateGlobalWatch = ({
+  repoRoot,
+  changedEntries,
+  patterns,
+  listFilesRecursive,
+}) => {
+  const effectivePatterns = Array.isArray(patterns) && patterns.length > 0 ? patterns : getDefaultGlobalWatchPatterns();
+  const patternRegexes = effectivePatterns.map((pattern) => globToRegex(normalizePath(pattern).replace(/^\.\//, '')));
+  const closure = resolveGlobalWatchClosure({ repoRoot, patterns: effectivePatterns, listFilesRecursive });
+  const matched = new Set();
+
+  for (const entry of changedEntries) {
+    for (const candidate of [entry.effectivePath, entry.oldPath, entry.newPath]) {
+      if (!candidate) continue;
+      const relative = normalizePath(candidate).replace(/^\.\//, '');
+      const absolute = path.resolve(repoRoot, relative);
+      const byPattern = patternRegexes.some((regex) => regex.test(relative));
+      const byClosure = closure.resolvedFilesAbs.has(absolute);
+      if (byPattern || byClosure) matched.add(relative);
+    }
+  }
+
+  return {
+    matchedPaths: Array.from(matched).sort((a, b) => a.localeCompare(b)),
+    resolvedFiles: closure.resolvedFilesRelative,
+  };
+};
+
+module.exports = {
+  getDefaultGlobalWatchPatterns,
+  evaluateGlobalWatch,
+  __testOnly: {
+    globToRegex,
+    resolveGlobalWatchClosure,
+  },
+};