@uipath/packager-tool-workflowcompiler 1.199.0 → 1.201.0-preview.115

package/dist/i18n/locales/en.d.ts

@@ -28,7 +28,7 @@ export declare const en: {
                 readonly checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}";
                 readonly foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache";
                 readonly notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...";
-                readonly restoringPackage: "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...";
+                readonly restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...';
                 readonly runningDotnetRestore: "[PathResolver] Running dotnet restore...";
                 readonly restoreCompleted: "[PathResolver] dotnet restore completed";
                 readonly installCompleted: "[PathResolver] Compiler restored successfully";

package/dist/index.js

@@ -789,7 +789,7 @@ function addSdkUserAgentHeader(headers, userAgent) {
 }
 var package_default = {
   name: "@uipath/packager-orchestrator-client",
-  version: "1.199.0",
+  version: "1.201.0",
   description: "UiPath packager client for Orchestrator package-feed interaction (feed discovery + NuGet source composition)",
   type: "module",
   private: true,
@@ -828,7 +828,7 @@ var package_default = {
     "@uipath/common": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@vitest/coverage-v8": "^4.1.6",
-    typescript: "^6.0.2",
+    typescript: "^7.0.2",
     vitest: "^4.1.6"
   }
 };
@@ -992,7 +992,7 @@ import {
   TemporaryStorageService as TemporaryStorageService2,
   translate as translate3
 } from "@uipath/solutionpackager-tool-core";
-var NUGET_FEED_URL = "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+var NUGET_FEED_URL = "https://pkgs.uipath.com/internal/index.json";
 var WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 var PLATFORM_PACKAGE_IDS = {
   win32: "UiPath.WorkflowCompiler.Windows",
@@ -1157,6 +1157,7 @@ class WorkflowCompilerExecutor {
     return new Promise((resolve) => {
       let result = null;
       const fallbackErrors = [];
+      const analyzerFindings = [];
       const childProcess = this.spawnProcess(executable, commandArgs, workflowCompilerConfig.dotnetEnv);
       let stdoutEnded = false;
       let stderrEnded = false;
@@ -1172,7 +1173,7 @@ class WorkflowCompilerExecutor {
               errorCode: result.errorCode
             }));
             const toolResult = new ToolResult(result.errorCode, result.message, result.outputPackages);
-            toolResult.details = getAdditionalResultDetails(result);
+            toolResult.details = withAnalyzerFindings(getAdditionalResultDetails(result), analyzerFindings);
             resolve(toolResult);
           } else {
             const exitCode = childProcess.exitCode ?? -1;
@@ -1202,8 +1203,8 @@ class WorkflowCompilerExecutor {
           checkComplete();
         }
       };
-      this.setupStdoutHandling(childProcess, streamCompletion, (r) => result = r);
-      this.setupStderrHandling(childProcess, streamCompletion, fallbackErrors);
+      this.setupStdoutHandling(childProcess, streamCompletion, (r) => result = r, analyzerFindings);
+      this.setupStderrHandling(childProcess, streamCompletion, fallbackErrors, analyzerFindings);
       this.setupProcessEventHandlers(childProcess, streamCompletion, resolve);
       this.setupCancellationHandler(childProcess, cancellationToken, resolve);
     });
@@ -1225,7 +1226,7 @@ class WorkflowCompilerExecutor {
       command: fullCommand.join(" ")
     }));
   }
-  setupStdoutHandling(childProcess, streamCompletion, onResult) {
+  setupStdoutHandling(childProcess, streamCompletion, onResult, analyzerFindings) {
     if (!childProcess.stdout) {
       streamCompletion.markStdoutEnded();
       return;
@@ -1239,24 +1240,29 @@ class WorkflowCompilerExecutor {
       for (const line of lines) {
         if (!line.trim())
           continue;
-        this.processOutputLine(line, onResult);
+        this.processOutputLine(line, onResult, analyzerFindings);
       }
     });
     childProcess.stdout.on("end", () => {
       if (buffer.trim()) {
-        this.processOutputLine(buffer, onResult);
+        this.processOutputLine(buffer, onResult, analyzerFindings);
       }
       streamCompletion.markStdoutEnded();
     });
   }
-  processOutputLine(line, onResult) {
+  processOutputLine(line, onResult, analyzerFindings) {
     const entry = this.parseOutputEntry(line);
     if (!entry)
       return;
     if (entry.type === "Result") {
       onResult(entry);
     } else if (entry.type === "Log") {
-      this.logMessage(entry);
+      const log = entry;
+      const finding = toAnalyzerFinding(log);
+      if (finding) {
+        analyzerFindings.push(finding);
+      }
+      this.logMessage(log);
     } else if (entry.type === "Progress") {
       this.logProgress(entry);
     }
@@ -1279,7 +1285,7 @@ class WorkflowCompilerExecutor {
     const separator = percent && progress.message ? " - " : "";
     this.logger.progress(`${percent}${separator}${progress.message ?? ""}`);
   }
-  setupStderrHandling(childProcess, streamCompletion, fallbackErrors) {
+  setupStderrHandling(childProcess, streamCompletion, fallbackErrors, analyzerFindings) {
     if (!childProcess.stderr) {
       streamCompletion.markStderrEnded();
       return;
@@ -1293,20 +1299,25 @@ class WorkflowCompilerExecutor {
       for (const line of lines) {
         if (!line.trim())
           continue;
-        this.processErrorLine(line, fallbackErrors);
+        this.processErrorLine(line, fallbackErrors, analyzerFindings);
       }
     });
     childProcess.stderr.on("end", () => {
       if (buffer.trim()) {
-        this.processErrorLine(buffer, fallbackErrors);
+        this.processErrorLine(buffer, fallbackErrors, analyzerFindings);
       }
       streamCompletion.markStderrEnded();
     });
   }
-  processErrorLine(line, fallbackErrors) {
+  processErrorLine(line, fallbackErrors, analyzerFindings) {
     const entry = this.parseOutputEntry(line);
     if (entry && entry.type === "Log") {
-      this.logger.error(entry.message);
+      const log = entry;
+      const finding = toAnalyzerFinding(log);
+      if (finding) {
+        analyzerFindings.push(finding);
+      }
+      this.logger.error(log.message);
     } else {
       fallbackErrors.push(line);
       this.logger.error(line);
@@ -1370,8 +1381,68 @@ function getAdditionalResultDetails(result) {
   }
   return Object.keys(details).length > 0 ? details : undefined;
 }
+var ANALYZER_LOG_SOURCE = "Analyzer";
+function withAnalyzerFindings(details, findings) {
+  const fromEnvelope = details?.findings;
+  if (findings.length === 0 || Array.isArray(fromEnvelope) && fromEnvelope.length > 0) {
+    return details;
+  }
+  return { ...details, findings };
+}
+function toAnalyzerFinding(log) {
+  if (log.source !== ANALYZER_LOG_SOURCE) {
+    return;
+  }
+  const message = parseAnalyzerMessage(log.data) ?? {};
+  const activityId = message.ActivityId;
+  const item = message.Item;
+  return {
+    ...message,
+    ErrorCode: message.ErrorCode ?? log.code,
+    Description: message.Description ?? log.message,
+    FilePath: message.FilePath ?? log.filePath,
+    ErrorSeverity: message.ErrorSeverity ?? toErrorSeverity(log.logLevel),
+    ActivityIdRef: activityId?.IdRef ?? log.id,
+    AnalyzerItemName: item?.Name,
+    AnalyzerItemType: item?.Type
+  };
+}
+function toErrorSeverity(logLevel) {
+  switch (logLevel) {
+    case "Debug":
+    case "Trace":
+      return "Verbose";
+    case "Information":
+      return "Info";
+    default:
+      return logLevel;
+  }
+}
+function parseAnalyzerMessage(data) {
+  if (!data) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(data);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
 
 // src/workflow-compiler-tool.ts
+var NO_CLEANUP_SOURCE_FILES_MESSAGE = "no workflow xamls or coded source files";
+var CLEANUP_SOURCE_FILE_EXTENSIONS = [".xaml", ".cs", ".vb"];
+var CLEANUP_SOURCE_SCAN_SKIP_DIRS = new Set([
+  ".git",
+  ".local",
+  ".project",
+  "bin",
+  "dist",
+  "node_modules",
+  "obj"
+]);
+
 class WorkflowCompilerTool extends ProjectTool {
   context;
   executor;
@@ -1575,9 +1646,52 @@ class WorkflowCompilerTool extends ProjectTool {
         args.push(`--nuget-config`, paths.userNugetConfigPath);
       }
       const result = await this.executor.executeAsync("remove-unused-dependencies", args, cancellationToken);
+      if (await this.shouldRetryCleanupNoSourceFalseNegativeAsync(result, options.projectPath)) {
+        this.logger.warn("[WorkflowCompiler] remove-unused-dependencies reported no workflow/source files even though the project contains source files; retrying once.");
+        const retryResult = await this.executor.executeAsync("remove-unused-dependencies", args, cancellationToken);
+        return this.toProjectCleanupResult(retryResult);
+      }
       return this.toProjectCleanupResult(result);
     });
   }
+  async shouldRetryCleanupNoSourceFalseNegativeAsync(result, projectPath) {
+    if (result.isSuccess) {
+      return false;
+    }
+    const message = result.message?.toLowerCase();
+    if (!message?.includes(NO_CLEANUP_SOURCE_FILES_MESSAGE)) {
+      return false;
+    }
+    return await this.hasCleanupSourceFilesAsync(projectPath);
+  }
+  async hasCleanupSourceFilesAsync(projectPath) {
+    let entries;
+    try {
+      entries = await this.fileSystem.readdir(projectPath);
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const lowerEntry = entry.toLowerCase();
+      const fullPath = this.fileSystem.path.join(projectPath, entry);
+      let stats;
+      try {
+        stats = await this.fileSystem.stat(fullPath);
+      } catch {
+        continue;
+      }
+      if (!stats) {
+        continue;
+      }
+      if (stats.isFile() && CLEANUP_SOURCE_FILE_EXTENSIONS.some((extension) => lowerEntry.endsWith(extension))) {
+        return true;
+      }
+      if (stats.isDirectory() && !CLEANUP_SOURCE_SCAN_SKIP_DIRS.has(lowerEntry) && await this.hasCleanupSourceFilesAsync(fullPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
   toProjectCleanupResult(result) {
     const raw = result.details?.removeUnusedDependencies;
     if (!raw) {
@@ -1666,4 +1780,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=D679068934126E3664756E2164756E21
+//# debugId=8617FFB8E317023F64756E2164756E21

package/dist/output-entry.d.ts

@@ -15,12 +15,18 @@ export interface IOutputMessage {
     inputId?: string;
 }
 /**
- * Log message from workflow compiler output
+ * Log message from workflow compiler output. Analyzer findings are reported only here.
  */
 export interface IOutputLog extends IOutputMessage {
     type: OutputMessageType.Log;
     message: string;
-    logLevel: "Information" | "Warning" | "Error";
+    logLevel: "Trace" | "Debug" | "Information" | "Warning" | "Error" | "None";
+    source?: string;
+    code?: string;
+    filePath?: string;
+    id?: string;
+    /** Serialized `AnalyzerMessage`. */
+    data?: string;
 }
 /**
  * Progress update from workflow compiler output

package/dist/workflow-compiler-tool.d.ts

@@ -13,6 +13,8 @@ export declare class WorkflowCompilerTool extends ProjectTool {
     buildAsync(options: IProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     cleanupAsync(options: IProjectCleanupOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    private shouldRetryCleanupNoSourceFalseNegativeAsync;
+    private hasCleanupSourceFilesAsync;
     /**
      * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
      * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.199.0",
+  "version": "1.201.0-preview.115",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -25,8 +25,8 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@uipath/solutionpackager-tool-core": "1.199.0"
+    "@uipath/solutionpackager-tool-core": "1.201.0"
   },
   "dependencies": {},
-  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
+  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
 }

package/src/output-entry.ts

@@ -17,12 +17,18 @@ export interface IOutputMessage {
 }
 
 /**
- * Log message from workflow compiler output
+ * Log message from workflow compiler output. Analyzer findings are reported only here.
  */
 export interface IOutputLog extends IOutputMessage {
     type: OutputMessageType.Log;
     message: string;
-    logLevel: "Information" | "Warning" | "Error";
+    logLevel: "Trace" | "Debug" | "Information" | "Warning" | "Error" | "None";
+    source?: string;
+    code?: string;
+    filePath?: string;
+    id?: string;
+    /** Serialized `AnalyzerMessage`. */
+    data?: string;
 }
 
 /**

package/src/workflow-compiler-executor.ts

@@ -82,6 +82,7 @@ export class WorkflowCompilerExecutor {
         return new Promise((resolve) => {
             let result: IOutputResult | null = null;
             const fallbackErrors: string[] = [];
+            const analyzerFindings: Record<string, unknown>[] = [];
 
             const childProcess = this.spawnProcess(
                 executable,
@@ -115,7 +116,10 @@ export class WorkflowCompilerExecutor {
                             result.message,
                             result.outputPackages,
                         );
-                        toolResult.details = getAdditionalResultDetails(result);
+                        toolResult.details = withAnalyzerFindings(
+                            getAdditionalResultDetails(result),
+                            analyzerFindings,
+                        );
                         resolve(toolResult);
                     } else {
                         const exitCode = childProcess.exitCode ?? -1;
@@ -163,11 +167,13 @@ export class WorkflowCompilerExecutor {
                 childProcess,
                 streamCompletion,
                 (r) => (result = r),
+                analyzerFindings,
             );
             this.setupStderrHandling(
                 childProcess,
                 streamCompletion,
                 fallbackErrors,
+                analyzerFindings,
             );
             this.setupProcessEventHandlers(
                 childProcess,
@@ -219,6 +225,7 @@ export class WorkflowCompilerExecutor {
         childProcess: ChildProcess,
         streamCompletion: StreamCompletion,
         onResult: (result: IOutputResult) => void,
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         if (!childProcess.stdout) {
             streamCompletion.markStdoutEnded();
@@ -233,13 +240,13 @@ export class WorkflowCompilerExecutor {
             buffer = lines.pop()!;
             for (const line of lines) {
                 if (!line.trim()) continue;
-                this.processOutputLine(line, onResult);
+                this.processOutputLine(line, onResult, analyzerFindings);
             }
         });
 
         childProcess.stdout.on("end", () => {
             if (buffer.trim()) {
-                this.processOutputLine(buffer, onResult);
+                this.processOutputLine(buffer, onResult, analyzerFindings);
             }
             streamCompletion.markStdoutEnded();
         });
@@ -248,6 +255,7 @@ export class WorkflowCompilerExecutor {
     private processOutputLine(
         line: string,
         onResult: (result: IOutputResult) => void,
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         const entry = this.parseOutputEntry(line);
         if (!entry) return;
@@ -255,7 +263,12 @@ export class WorkflowCompilerExecutor {
         if (entry.type === "Result") {
             onResult(entry as IOutputResult);
         } else if (entry.type === "Log") {
-            this.logMessage(entry as IOutputLog);
+            const log = entry as IOutputLog;
+            const finding = toAnalyzerFinding(log);
+            if (finding) {
+                analyzerFindings.push(finding);
+            }
+            this.logMessage(log);
         } else if (entry.type === "Progress") {
             this.logProgress(entry as IOutputProgress);
         }
@@ -285,6 +298,7 @@ export class WorkflowCompilerExecutor {
         childProcess: ChildProcess,
         streamCompletion: StreamCompletion,
         fallbackErrors: string[],
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         if (!childProcess.stderr) {
             streamCompletion.markStderrEnded();
@@ -298,23 +312,32 @@ export class WorkflowCompilerExecutor {
             buffer = lines.pop()!;
             for (const line of lines) {
                 if (!line.trim()) continue;
-                this.processErrorLine(line, fallbackErrors);
+                this.processErrorLine(line, fallbackErrors, analyzerFindings);
             }
         });
 
         childProcess.stderr.on("end", () => {
             if (buffer.trim()) {
-                this.processErrorLine(buffer, fallbackErrors);
+                this.processErrorLine(buffer, fallbackErrors, analyzerFindings);
             }
             streamCompletion.markStderrEnded();
         });
     }
 
-    private processErrorLine(line: string, fallbackErrors: string[]): void {
+    private processErrorLine(
+        line: string,
+        fallbackErrors: string[],
+        analyzerFindings: Record<string, unknown>[],
+    ): void {
         const entry = this.parseOutputEntry(line);
 
         if (entry && entry.type === "Log") {
-            this.logger.error((entry as IOutputLog).message);
+            const log = entry as IOutputLog;
+            const finding = toAnalyzerFinding(log);
+            if (finding) {
+                analyzerFindings.push(finding);
+            }
+            this.logger.error(log.message);
         } else {
             fallbackErrors.push(line);
             this.logger.error(line);
@@ -434,3 +457,74 @@ function getAdditionalResultDetails(
 
     return Object.keys(details).length > 0 ? details : undefined;
 }
+
+const ANALYZER_LOG_SOURCE = "Analyzer";
+
+/** Only a *populated* envelope array wins — `CommandResult` defaults its lists to `[]`. */
+function withAnalyzerFindings(
+    details: Record<string, unknown> | undefined,
+    findings: Record<string, unknown>[],
+): Record<string, unknown> | undefined {
+    const fromEnvelope = details?.findings;
+    if (
+        findings.length === 0 ||
+        (Array.isArray(fromEnvelope) && fromEnvelope.length > 0)
+    ) {
+        return details;
+    }
+    return { ...details, findings };
+}
+
+/** Flattened because consumers match flat keys only; the payload omits null members. */
+function toAnalyzerFinding(
+    log: IOutputLog,
+): Record<string, unknown> | undefined {
+    if (log.source !== ANALYZER_LOG_SOURCE) {
+        return undefined;
+    }
+
+    const message = parseAnalyzerMessage(log.data) ?? {};
+    const activityId = message.ActivityId as { IdRef?: string } | undefined;
+    const item = message.Item as { Name?: string; Type?: string } | undefined;
+    return {
+        ...message,
+        ErrorCode: message.ErrorCode ?? log.code,
+        Description: message.Description ?? log.message,
+        FilePath: message.FilePath ?? log.filePath,
+        ErrorSeverity: message.ErrorSeverity ?? toErrorSeverity(log.logLevel),
+        ActivityIdRef: activityId?.IdRef ?? log.id,
+        AnalyzerItemName: item?.Name,
+        AnalyzerItemType: item?.Type,
+    };
+}
+
+/** Undo the compiler's `TraceLevel` → `LogLevel` mapping, so a consumer's lookup still matches. */
+function toErrorSeverity(logLevel: IOutputLog["logLevel"]): string {
+    switch (logLevel) {
+        case "Debug":
+        case "Trace":
+            return "Verbose";
+        case "Information":
+            return "Info";
+        default:
+            return logLevel;
+    }
+}
+
+function parseAnalyzerMessage(
+    data: string | undefined,
+): Record<string, unknown> | undefined {
+    if (!data) {
+        return undefined;
+    }
+    try {
+        const parsed: unknown = JSON.parse(data);
+        return typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? (parsed as Record<string, unknown>)
+            : undefined;
+    } catch {
+        return undefined;
+    }
+}

package/src/workflow-compiler-path-resolver.ts

@@ -11,8 +11,7 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 import { workflowCompilerConfig } from "./workflow-compiler-config.js";
 
-const NUGET_FEED_URL =
-    "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+const NUGET_FEED_URL = "https://pkgs.uipath.com/internal/index.json";
 
 const WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 

package/src/workflow-compiler-tool.ts

@@ -1,5 +1,6 @@
 import { OrchestratorFeedComposer } from "@uipath/packager-orchestrator-client";
 import {
+    type FileSystemStats,
     type IFileSystem,
     type IProjectBuildOptions,
     type IProjectCleanupOptions,
@@ -25,6 +26,19 @@ import { WorkflowCompilerExecutor } from "./workflow-compiler-executor.js";
  */
 type RawRemoveUnusedDependenciesResult = WorkflowCompilerCleanupPayload;
 
+const NO_CLEANUP_SOURCE_FILES_MESSAGE =
+    "no workflow xamls or coded source files";
+const CLEANUP_SOURCE_FILE_EXTENSIONS = [".xaml", ".cs", ".vb"];
+const CLEANUP_SOURCE_SCAN_SKIP_DIRS = new Set([
+    ".git",
+    ".local",
+    ".project",
+    "bin",
+    "dist",
+    "node_modules",
+    "obj",
+]);
+
 /**
  * The two NuGet-source channels the WorkflowCompiler accepts, kept apart on
  * purpose:
@@ -325,10 +339,86 @@ export class WorkflowCompilerTool extends ProjectTool {
                 args,
                 cancellationToken,
             );
+            if (
+                await this.shouldRetryCleanupNoSourceFalseNegativeAsync(
+                    result,
+                    options.projectPath,
+                )
+            ) {
+                this.logger.warn(
+                    "[WorkflowCompiler] remove-unused-dependencies reported no workflow/source files even though the project contains source files; retrying once.",
+                );
+                const retryResult = await this.executor.executeAsync(
+                    "remove-unused-dependencies",
+                    args,
+                    cancellationToken,
+                );
+                return this.toProjectCleanupResult(retryResult);
+            }
             return this.toProjectCleanupResult(result);
         });
     }
 
+    private async shouldRetryCleanupNoSourceFalseNegativeAsync(
+        result: ToolResult,
+        projectPath: string,
+    ): Promise<boolean> {
+        if (result.isSuccess) {
+            return false;
+        }
+
+        const message = result.message?.toLowerCase();
+        if (!message?.includes(NO_CLEANUP_SOURCE_FILES_MESSAGE)) {
+            return false;
+        }
+
+        return await this.hasCleanupSourceFilesAsync(projectPath);
+    }
+
+    private async hasCleanupSourceFilesAsync(
+        projectPath: string,
+    ): Promise<boolean> {
+        let entries: string[];
+        try {
+            entries = await this.fileSystem.readdir(projectPath);
+        } catch {
+            return false;
+        }
+
+        for (const entry of entries) {
+            const lowerEntry = entry.toLowerCase();
+            const fullPath = this.fileSystem.path.join(projectPath, entry);
+            let stats: FileSystemStats | null;
+            try {
+                stats = await this.fileSystem.stat(fullPath);
+            } catch {
+                continue;
+            }
+            if (!stats) {
+                continue;
+            }
+
+            if (
+                stats.isFile() &&
+                CLEANUP_SOURCE_FILE_EXTENSIONS.some((extension) =>
+                    lowerEntry.endsWith(extension),
+                )
+            ) {
+                return true;
+            }
+
+            if (
+                stats.isDirectory() &&
+                !CLEANUP_SOURCE_SCAN_SKIP_DIRS.has(lowerEntry) &&
+                (await this.hasCleanupSourceFilesAsync(fullPath))
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
      * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,