pumuki 6.3.307 → 6.3.309

package/core/facts/detectors/text/ios.ts

@@ -204,6 +204,25 @@ export const hasSwiftNonPascalCaseTypeDeclarationUsage = (source: string): boole
   return collectSwiftNonPascalCaseTypeDeclarationLines(source).length > 0;
 };
 
+export const collectSwiftEndpointEnumLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+  const endpointEnumPattern =
+    /\benum\s+(?:APIEndpoint|[A-Za-z_][A-Za-z0-9_]*(?:Endpoint|Endpoints))\b/;
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (endpointEnumPattern.test(line)) {
+      matches.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftEndpointEnumUsage = (source: string): boolean => {
+  return collectSwiftEndpointEnumLines(source).length > 0;
+};
+
 const collectSwiftMethodBodyLines = (
   source: string,
   methodPattern: RegExp,
@@ -857,6 +876,62 @@ export const hasSwiftTaskDetachedUsage = (source: string): boolean => {
   });
 };
 
+const swiftCancellationCheckPattern =
+  /\bTask\s*\.\s*isCancelled\b|\bTask\s*\.\s*checkCancellation\s*\(/;
+
+const swiftLoopPattern = /\b(?:for\s+[A-Za-z_][A-Za-z0-9_]*\s+in|while\s+|repeat\b)/;
+
+export const collectSwiftLongAsyncOperationWithoutCancellationCheckLines = (
+  source: string
+): readonly number[] => {
+  const lines = source.split(/\r?\n/);
+  const matches: number[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const declarationLine = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (!/\bfunc\s+[A-Za-z_][A-Za-z0-9_]*[\s\S]*\basync\b/.test(declarationLine)) {
+      continue;
+    }
+
+    let braceDepth =
+      countTokenOccurrences(declarationLine, '{') - countTokenOccurrences(declarationLine, '}');
+    if (braceDepth <= 0 && !declarationLine.includes('{')) {
+      continue;
+    }
+
+    const localLoopLines: number[] = [];
+    let hasCancellationCheck = swiftCancellationCheckPattern.test(declarationLine);
+
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      const line = stripSwiftLineForSemanticScan(lines[cursor] ?? '');
+      if (swiftCancellationCheckPattern.test(line)) {
+        hasCancellationCheck = true;
+      }
+      if (swiftLoopPattern.test(line)) {
+        localLoopLines.push(cursor + 1);
+      }
+
+      braceDepth += countTokenOccurrences(line, '{');
+      braceDepth -= countTokenOccurrences(line, '}');
+      if (braceDepth <= 0) {
+        break;
+      }
+    }
+
+    if (!hasCancellationCheck && localLoopLines.length > 0) {
+      matches.push(...localLoopLines);
+    }
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftLongAsyncOperationWithoutCancellationCheckUsage = (
+  source: string
+): boolean => {
+  return collectSwiftLongAsyncOperationWithoutCancellationCheckLines(source).length > 0;
+};
+
 const findMatchingSwiftBrace = (source: string, openBraceIndex: number): number => {
   let depth = 0;
   for (let index = openBraceIndex; index < source.length; index += 1) {
@@ -899,6 +974,20 @@ export const hasSwiftAsyncWithoutAwaitUsage = (source: string): boolean => {
   return false;
 };
 
+export const collectSwiftDummyAwaitLines = (source: string): readonly number[] => {
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bawait\s+Task\s*\.\s*yield\s*\(\s*\)/),
+    ...collectSwiftRegexLines(
+      source,
+      /\bawait\s+Task\s*\.\s*sleep\s*\([^)]*(?:nanoseconds\s*:\s*0\b|for\s*:\s*\.(?:zero|seconds\s*\(\s*0\s*\)))/,
+    ),
+  ]);
+};
+
+export const hasSwiftDummyAwaitUsage = (source: string): boolean => {
+  return collectSwiftDummyAwaitLines(source).length > 0;
+};
+
 export const hasSwiftEmptyCatchUsage = (source: string): boolean => {
   const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
   return /\bcatch(?:\s+(?:let|var)\s+[A-Za-z_][A-Za-z0-9_]*)?\s*\{\s*\}/.test(sanitized);
@@ -952,6 +1041,57 @@ export const hasSwiftPackageToolsVersionBelow62Usage = (source: string): boolean
   return collectSwiftPackageToolsVersionBelow62Lines(source).length > 0;
 };
 
+export const collectSwiftPackageDefaultIsolationNotMainActorLines = (
+  source: string
+): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const match = /\.defaultIsolation\s*\(\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\)/.exec(line);
+    if (!match) {
+      return;
+    }
+
+    const value = (match[1] ?? '').trim().toLowerCase();
+    if (value !== 'mainactor' && value !== 'mainactor.self') {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftPackageDefaultIsolationNotMainActorUsage = (source: string): boolean => {
+  return collectSwiftPackageDefaultIsolationNotMainActorLines(source).length > 0;
+};
+
+export const collectSwiftPackageStrictConcurrencyBelowCompleteLines = (
+  source: string
+): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = rawLine.trim();
+    if (line.startsWith('//')) {
+      return;
+    }
+    const match =
+      /\.enable(?:Experimental|Upcoming)Feature\s*\(\s*"StrictConcurrency\s*=\s*(minimal|targeted)"\s*\)/i.exec(
+        line
+      );
+    if (match) {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftPackageStrictConcurrencyBelowCompleteUsage = (source: string): boolean => {
+  return collectSwiftPackageStrictConcurrencyBelowCompleteLines(source).length > 0;
+};
+
 export const collectSwiftStrictConcurrencyBelowCompleteLines = (source: string): readonly number[] => {
   const lines: number[] = [];
 
@@ -975,6 +1115,271 @@ export const hasSwiftStrictConcurrencyBelowCompleteUsage = (source: string): boo
   return collectSwiftStrictConcurrencyBelowCompleteLines(source).length > 0;
 };
 
+export const collectSwiftDefaultActorIsolationNotMainActorLines = (
+  source: string
+): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const match = /\bSWIFT_DEFAULT_ACTOR_ISOLATION\s*=\s*([A-Za-z_][A-Za-z0-9_.]*)\s*;?/.exec(
+      line
+    );
+    if (!match) {
+      return;
+    }
+
+    const value = (match[1] ?? '').trim().toLowerCase();
+    if (value !== 'mainactor' && value !== 'mainactor.self') {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftDefaultActorIsolationNotMainActorUsage = (source: string): boolean => {
+  return collectSwiftDefaultActorIsolationNotMainActorLines(source).length > 0;
+};
+
+export const collectSwiftUpcomingFeatureDisabledLines = (source: string): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const upcomingFeatureMatch =
+      /\bSWIFT_UPCOMING_FEATURE_[A-Za-z0-9_]+\s*=\s*([A-Za-z0-9_]+)\s*;?/.exec(line);
+    if (upcomingFeatureMatch) {
+      const value = (upcomingFeatureMatch[1] ?? '').trim().toLowerCase();
+      if (value === 'no' || value === 'false' || value === '0') {
+        lines.push(index + 1);
+      }
+      return;
+    }
+
+    const experimentalFeaturesMatch =
+      /\bSWIFT_ENABLE_EXPERIMENTAL_FEATURES\s*=\s*(.*?)\s*;?$/.exec(line);
+    if (!experimentalFeaturesMatch) {
+      return;
+    }
+
+    const value = (experimentalFeaturesMatch[1] ?? '').trim().toLowerCase();
+    if (value === '' || value === 'no' || value === 'false' || value === '0') {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftUpcomingFeatureDisabledUsage = (source: string): boolean => {
+  return collectSwiftUpcomingFeatureDisabledLines(source).length > 0;
+};
+
+const swiftUiStateOwnerDeclarationPattern =
+  /\b(?:final\s+)?(?:class|struct)\s+([A-Za-z_][A-Za-z0-9_]*(?:ViewModel|Presenter|Store))\b/;
+
+const hasSwiftMainActorAnnotationNear = (
+  lines: readonly string[],
+  declarationIndex: number
+): boolean => {
+  const start = Math.max(0, declarationIndex - 3);
+  const context = lines
+    .slice(start, declarationIndex + 1)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+  return /@MainActor\b/.test(context);
+};
+
+const hasSwiftObservableUiStateEvidence = (
+  lines: readonly string[],
+  declarationIndex: number
+): boolean => {
+  const annotationStart = Math.max(0, declarationIndex - 2);
+  const end = Math.min(lines.length, declarationIndex + 60);
+  const annotationContext = lines
+    .slice(annotationStart, declarationIndex + 1)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+  const bodyContext = lines
+    .slice(declarationIndex, end)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+
+  return (
+    /@Observable\b/.test(annotationContext) ||
+    /\bObservableObject\b/.test(bodyContext) ||
+    /@Published\b/.test(bodyContext)
+  );
+};
+
+export const collectSwiftUiStateWithoutMainActorLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!swiftUiStateOwnerDeclarationPattern.test(line)) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, index)) {
+      return;
+    }
+    if (!hasSwiftObservableUiStateEvidence(lines, index)) {
+      return;
+    }
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftUiStateWithoutMainActorUsage = (source: string): boolean => {
+  return collectSwiftUiStateWithoutMainActorLines(source).length > 0;
+};
+
+const swiftSharedStateOwnerDeclarationPattern =
+  /\b(?:final\s+)?class\s+([A-Za-z_][A-Za-z0-9_]*(?:Cache|Manager|Session|Store|Repository))\b/;
+
+const findSwiftDeclarationBlockEnd = (lines: readonly string[], declarationIndex: number): number => {
+  let depth = 0;
+  let started = false;
+
+  for (let index = declarationIndex; index < lines.length; index += 1) {
+    const line = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    for (const char of line) {
+      if (char === '{') {
+        depth += 1;
+        started = true;
+      } else if (char === '}') {
+        depth -= 1;
+        if (started && depth <= 0) {
+          return index + 1;
+        }
+      }
+    }
+  }
+
+  return Math.min(lines.length, declarationIndex + 80);
+};
+
+const hasSwiftSharedMutableStateBody = (body: string): boolean => {
+  return (
+    /\b(?:private\s+|fileprivate\s+|internal\s+|public\s+|open\s+)?var\s+[A-Za-z_][A-Za-z0-9_]*\b/.test(
+      body
+    ) &&
+    /\bfunc\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(body) &&
+    !/@(?:Observable|Published)\b/.test(body) &&
+    !/\bObservableObject\b/.test(body)
+  );
+};
+
+export const collectSwiftSharedMutableStateWithoutActorLines = (
+  source: string
+): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!swiftSharedStateOwnerDeclarationPattern.test(line)) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, index)) {
+      return;
+    }
+
+    const blockEnd = findSwiftDeclarationBlockEnd(lines, index);
+    const body = lines
+      .slice(index, blockEnd)
+      .map((candidate) => stripSwiftLineForSemanticScan(candidate))
+      .join('\n');
+
+    if (!hasSwiftSharedMutableStateBody(body)) {
+      return;
+    }
+
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftSharedMutableStateWithoutActorUsage = (source: string): boolean => {
+  return collectSwiftSharedMutableStateWithoutActorLines(source).length > 0;
+};
+
+const swiftActorPatchOwnerDeclarationPattern =
+  /\b(?:final\s+)?(?:class|struct)\s+([A-Za-z_][A-Za-z0-9_]*(?:ViewModel|Presenter|Store|Manager))\b/;
+
+const findNearestSwiftActorPatchOwnerIndex = (
+  lines: readonly string[],
+  usageIndex: number
+): number | undefined => {
+  const start = Math.max(0, usageIndex - 80);
+  for (let index = usageIndex; index >= start; index -= 1) {
+    const line = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (swiftActorPatchOwnerDeclarationPattern.test(line)) {
+      return index;
+    }
+    if (/^\s*(?:actor|enum|protocol)\s+[A-Za-z_][A-Za-z0-9_]*\b/.test(line)) {
+      return undefined;
+    }
+  }
+  return undefined;
+};
+
+export const collectSwiftMainActorRunPatchLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!/\bMainActor\s*\.\s*run\s*(?:\(|\{)/.test(line)) {
+      return;
+    }
+
+    const ownerIndex = findNearestSwiftActorPatchOwnerIndex(lines, index);
+    if (ownerIndex === undefined) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, ownerIndex)) {
+      return;
+    }
+
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftMainActorRunPatchUsage = (source: string): boolean => {
+  return collectSwiftMainActorRunPatchLines(source).length > 0;
+};
+
+const swiftNavigationPathRestorationPattern =
+  /@(?:SceneStorage|AppStorage)\b|\bCodableRepresentation\b|\.codable\b|\b(?:restore|rehydrate|persist|save|load)[A-Za-z0-9_]*(?:Navigation)?Path\b/i;
+
+export const collectSwiftNavigationPathWithoutRestorationLines = (
+  source: string
+): readonly number[] => {
+  const lines = collectSwiftRegexLines(source, /\bNavigationPath\s*\(/);
+  if (lines.length === 0) {
+    return [];
+  }
+
+  const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
+  if (swiftNavigationPathRestorationPattern.test(sanitized)) {
+    return [];
+  }
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftNavigationPathWithoutRestorationUsage = (source: string): boolean => {
+  return collectSwiftNavigationPathWithoutRestorationLines(source).length > 0;
+};
+
 export const hasSwiftOnAppearTaskUsage = (source: string): boolean => {
   return collectSwiftOnAppearTaskLines(source).length > 0;
 };
@@ -1474,6 +1879,18 @@ export const hasSwiftMainThreadBlockingSleepUsage = (source: string): boolean =>
   });
 };
 
+export const collectSwiftThreadCentricDebuggingLines = (source: string): readonly number[] => {
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bThread\s*\.\s*(?:current|isMainThread)\b/),
+    ...collectSwiftRegexLines(source, /\bpthread_self\s*\(/),
+    ...collectSwiftRegexLines(source, /\bpthread_mach_thread_np\s*\(/),
+  ]);
+};
+
+export const hasSwiftThreadCentricDebuggingUsage = (source: string): boolean => {
+  return collectSwiftThreadCentricDebuggingLines(source).length > 0;
+};
+
 export const hasSwiftIconOnlyControlWithoutAccessibilityLabelUsage = (source: string): boolean => {
   const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
   const iconOnlyButtonPattern =
@@ -1569,6 +1986,227 @@ export const hasSwiftBindableMissingForObservableBindingUsage = (source: string)
   return collectSwiftBindableMissingForObservableBindingLines(source).length > 0;
 };
 
+const allowedCrossFeatureImportModules = new Set([
+  'Combine',
+  'CoreData',
+  'DesignSystem',
+  'Foundation',
+  'LocalAuthentication',
+  'MapKit',
+  'Navigation',
+  'Observation',
+  'PhotosUI',
+  'Shared',
+  'SharedKernel',
+  'SwiftData',
+  'SwiftUI',
+  'Testing',
+  'UIKit',
+  'XCTest',
+]);
+
+const featureNameFromSwiftPath = (path: string): string | undefined => {
+  const normalized = path.replace(/\\/g, '/');
+  const match = /\/Features\/([^/]+)\//.exec(normalized);
+  return match?.[1];
+};
+
+export const collectSwiftCrossFeatureImportLines = (
+  source: string,
+  path: string
+): readonly number[] => {
+  const currentFeature = featureNameFromSwiftPath(path);
+  if (!currentFeature) {
+    return [];
+  }
+
+  const lines: number[] = [];
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const match = /^\s*import\s+(?:@\w+\s+)?([A-Za-z_][A-Za-z0-9_]*)\b/.exec(line);
+    if (!match?.[1]) {
+      return;
+    }
+
+    const moduleName = match[1];
+    if (moduleName === currentFeature || allowedCrossFeatureImportModules.has(moduleName)) {
+      return;
+    }
+    if (moduleName.endsWith('Kit') || moduleName.startsWith('Swift')) {
+      return;
+    }
+
+    lines.push(index + 1);
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftCrossFeatureImportUsage = (source: string, path: string): boolean => {
+  return collectSwiftCrossFeatureImportLines(source, path).length > 0;
+};
+
+type SwiftArchitectureLayer = 'domain' | 'application' | 'presentation' | 'infrastructure';
+
+const forbiddenLayerImports: Record<SwiftArchitectureLayer, ReadonlySet<string>> = {
+  domain: new Set([
+    'Alamofire',
+    'AppKit',
+    'CloudKit',
+    'Combine',
+    'ComposableArchitecture',
+    'CoreData',
+    'Firebase',
+    'GRDB',
+    'Kingfisher',
+    'RealmSwift',
+    'Swinject',
+    'SwiftData',
+    'SwiftUI',
+    'UIKit',
+    'WatchKit',
+  ]),
+  application: new Set([
+    'Alamofire',
+    'AppKit',
+    'CloudKit',
+    'ComposableArchitecture',
+    'CoreData',
+    'Firebase',
+    'GRDB',
+    'Kingfisher',
+    'RealmSwift',
+    'Swinject',
+    'SwiftData',
+    'SwiftUI',
+    'UIKit',
+    'WatchKit',
+  ]),
+  presentation: new Set([
+    'Alamofire',
+    'CloudKit',
+    'CoreData',
+    'Firebase',
+    'GRDB',
+    'RealmSwift',
+    'Swinject',
+    'SwiftData',
+  ]),
+  infrastructure: new Set([]),
+};
+
+const swiftArchitectureLayerFromPath = (path: string): SwiftArchitectureLayer | undefined => {
+  const normalized = path.replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('/domain/')) {
+    return 'domain';
+  }
+  if (normalized.includes('/application/') || normalized.includes('/usecases/')) {
+    return 'application';
+  }
+  if (normalized.includes('/presentation/')) {
+    return 'presentation';
+  }
+  if (normalized.includes('/infrastructure/')) {
+    return 'infrastructure';
+  }
+  return undefined;
+};
+
+const hasForbiddenLayerImportName = (
+  layer: SwiftArchitectureLayer,
+  moduleName: string
+): boolean => {
+  if (forbiddenLayerImports[layer].has(moduleName)) {
+    return true;
+  }
+  if (moduleName.startsWith('Firebase')) {
+    return true;
+  }
+  if (layer === 'domain') {
+    return (
+      moduleName.includes('Application') ||
+      moduleName.includes('Presentation') ||
+      moduleName.includes('Infrastructure')
+    );
+  }
+  if (layer === 'application') {
+    return moduleName.includes('Presentation') || moduleName.includes('Infrastructure');
+  }
+  if (layer === 'presentation') {
+    return moduleName.includes('Infrastructure');
+  }
+  return false;
+};
+
+export const collectSwiftLayerDirectionViolationLines = (
+  source: string,
+  path: string
+): readonly number[] => {
+  const layer = swiftArchitectureLayerFromPath(path);
+  if (!layer) {
+    return [];
+  }
+
+  if (layer === 'infrastructure') {
+    return [];
+  }
+
+  const lines: number[] = [];
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const match = /^\s*import\s+(?:@\w+\s+)?([A-Za-z_][A-Za-z0-9_]*)\b/.exec(line);
+    if (match?.[1] && hasForbiddenLayerImportName(layer, match[1])) {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftLayerDirectionViolationUsage = (source: string, path: string): boolean => {
+  return collectSwiftLayerDirectionViolationLines(source, path).length > 0;
+};
+
+const isSwiftAppImplementationPath = (path: string): boolean => {
+  const normalized = path.replace(/\\/g, '/').toLowerCase();
+  if (
+    !normalized.endsWith('.swift') ||
+    /(^|\/)(tests?|uitests?|testsupport|fixtures?|mocks?)(\/|$)/.test(normalized) ||
+    /(?:tests?|spec)\.swift$/.test(normalized)
+  ) {
+    return false;
+  }
+  if (normalized.includes('/sources/') || normalized.includes('/public/') || normalized.includes('/exports/')) {
+    return false;
+  }
+  return normalized.includes('/apps/ios/') || normalized.includes('/ios/');
+};
+
+export const collectSwiftExcessivePublicApiLines = (
+  source: string,
+  path: string
+): readonly number[] => {
+  if (!isSwiftAppImplementationPath(path)) {
+    return [];
+  }
+
+  const lines: number[] = [];
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (
+      /^\s*(?:@(?:MainActor|Observable|objc|objcMembers|available|Published|ViewBuilder|discardableResult)[^\n]*\s*)*(?:public|open)\s+(?:(?:final|static|class|override|mutating|nonisolated)\s+)*(?:class|struct|enum|actor|protocol|extension|func|var|let|subscript|init)\b/.test(line)
+    ) {
+      lines.push(index + 1);
+    }
+  });
+
+  return lines.length >= 3 ? sortedUniqueLines(lines) : [];
+};
+
+export const hasSwiftExcessivePublicApiUsage = (source: string, path: string): boolean => {
+  return collectSwiftExcessivePublicApiLines(source, path).length > 0;
+};
+
 export const hasSwiftUncheckedSendableUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== '@' || !swiftSource.startsWith('@unchecked', index)) {
@@ -2051,6 +2689,72 @@ export const hasSwiftOnTapGestureWithoutButtonTraitUsage = (source: string): boo
   return collectSwiftOnTapGestureWithoutButtonTraitLines(source).length > 0;
 };
 
+export const collectSwiftGlassInteractiveOnStaticElementLines = (source: string): readonly number[] => {
+  const sanitizedLines = sanitizeSwiftSourceForMultilineRegex(source).split(/\r?\n/);
+  const originalLines = source.split(/\r?\n/);
+  const matches: number[] = [];
+
+  for (let index = 0; index < sanitizedLines.length; index += 1) {
+    const line = sanitizedLines[index] ?? '';
+    if (!/\.glassEffect\s*\(/.test(line)) {
+      continue;
+    }
+
+    const previousWindow = sanitizedLines.slice(Math.max(0, index - 4), index).join('\n');
+    const followingWindow = sanitizedLines
+      .slice(index, Math.min(sanitizedLines.length, index + 8))
+      .join('\n');
+    const modifierWindow = `${previousWindow}\n${followingWindow}`;
+    const currentStartsModifierChain = /^\s*\./.test(line);
+
+    if (!/\.interactive\s*\(/.test(modifierWindow)) {
+      continue;
+    }
+
+    if (
+      /\b(?:Button|NavigationLink|Menu|Toggle|Picker|Slider|Stepper|TextField|SecureField)\s*(?:<[^>]+>)?\s*\(/.test(
+        modifierWindow
+      ) ||
+      /^\s*\.onTapGesture\s*(?:\(|\{)/m.test(followingWindow) ||
+      (currentStartsModifierChain && /\.onTapGesture\s*(?:\(|\{)/.test(previousWindow)) ||
+      /^\s*\.accessibilityAction\s*\(/m.test(followingWindow) ||
+      (currentStartsModifierChain && /\.accessibilityAction\s*\(/.test(previousWindow)) ||
+      /^\s*\.accessibilityAddTraits\s*\(\s*(?:AccessibilityTraits\s*\.\s*)?\.isButton\s*\)/m.test(followingWindow) ||
+      (currentStartsModifierChain &&
+        /\.accessibilityAddTraits\s*\(\s*(?:AccessibilityTraits\s*\.\s*)?\.isButton\s*\)/.test(previousWindow)) ||
+      /^\s*\.focusable\s*\(\s*true\s*\)/m.test(followingWindow) ||
+      (currentStartsModifierChain && /\.focusable\s*\(\s*true\s*\)/.test(previousWindow))
+    ) {
+      continue;
+    }
+
+    if (!/\.glassEffect\s*\(/.test(stripSwiftLineForSemanticScan(originalLines[index] ?? ''))) {
+      continue;
+    }
+
+    matches.push(index + 1);
+  }
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftGlassInteractiveOnStaticElementUsage = (source: string): boolean => {
+  return collectSwiftGlassInteractiveOnStaticElementLines(source).length > 0;
+};
+
+export const collectSwiftGlassEffectIDWithoutNamespaceLines = (source: string): readonly number[] => {
+  const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
+  if (/@Namespace\b/.test(sanitized) || /\bNamespace\s*\.\s*ID\b/.test(sanitized)) {
+    return [];
+  }
+
+  return collectSwiftRegexLines(source, /\.\s*glassEffectID\s*\(/);
+};
+
+export const hasSwiftGlassEffectIDWithoutNamespaceUsage = (source: string): boolean => {
+  return collectSwiftGlassEffectIDWithoutNamespaceLines(source).length > 0;
+};
+
 export const hasSwiftStringFormatUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== 'S' || !hasIdentifierAt(swiftSource, index, 'String')) {
@@ -2257,6 +2961,24 @@ export const collectSwiftQuickNimbleLines = (source: string): readonly number[]
   ]);
 };
 
+export const hasSwiftThirdPartyUiTestFrameworkUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\bimport\s+(?:KIF|EarlGrey|GREYMatchers|GREYActions|Detox|Appium|Calabash)\b|\b(?:tester|KIFUITestActor|EarlGrey|GREYMatchers|GREYActions|Detox|Appium|Calabash)\b/
+  );
+};
+
+export const collectSwiftThirdPartyUiTestFrameworkLines = (source: string): readonly number[] => {
+  if (!hasSwiftThirdPartyUiTestFrameworkUsage(source)) {
+    return [];
+  }
+
+  return sortedUniqueLines([
+    ...collectSwiftRegexLines(source, /\bimport\s+(?:KIF|EarlGrey|GREYMatchers|GREYActions|Detox|Appium|Calabash)\b/),
+    ...collectSwiftRegexLines(source, /\b(?:tester|KIFUITestActor|EarlGrey|GREYMatchers|GREYActions|Detox|Appium|Calabash)\b/),
+  ]);
+};
+
 export const hasSwiftXCTestAssertionUsage = (source: string): boolean => {
   if (hasSwiftLegacyXCTestUiOrPerformanceUsage(source)) {
     return false;