Repository: biomejs/biome (language: rust)

Issue:
BREAKING: don't exit with an error for max limit files



Discussion / hints:
@ematipico Could you motivate this change?
It was pointed out to me that this diagnostic is emitted as an error **to the user**, while it's an expected behaviour inside the library. Biome by default doesn't handle the size of a certain limit, and since it's the default, it should ignore those files.

Now, the user that pointed out was a jerk and ignored them, however, that is true.

So I plan to change the logic, emit a diagnostic with a different severity, but still make the CLI working. It should not exit with an error code.

UPDATE: I updated the title of the issue 

Fix patch:
diff --git a/.changeset/reworked_how_large_files_behave.md b/.changeset/reworked_how_large_files_behave.md
new file mode 100644
index 000000000000..66ae9c2ce897
--- /dev/null
+++ b/.changeset/reworked_how_large_files_behave.md
@@ -0,0 +1,9 @@
+---
+cli: major
+---
+
+# Reworked how large files behave
+
+Previously, files that should exceed the configured size limit would throw an error, and the CLI would exit with an error code.
+
+Now, the CLI ignores the file, emits a *information* diagnostic and doesn't exit with an error code.
diff --git a/crates/biome_cli/src/execute/process_file.rs b/crates/biome_cli/src/execute/process_file.rs
index 79ea7dc3d871..1b475dc13aea 100644
--- a/crates/biome_cli/src/execute/process_file.rs
+++ b/crates/biome_cli/src/execute/process_file.rs
@@ -128,105 +128,104 @@ impl<'ctx, 'app> Deref for SharedTraversalOptions<'ctx, 'app> {
 /// content of the file and emit a diff or write the new content to the disk if
 /// write mode is enabled
 pub(crate) fn process_file(ctx: &TraversalOptions, biome_path: &BiomePath) -> FileResult {
-    tracing::trace_span!("process_file", path = ?biome_path).in_scope(move || {
-        let file_features = ctx
-            .workspace
-            .file_features(SupportsFeatureParams {
-                path: biome_path.clone(),
-                features: ctx.execution.to_feature(),
-            })
-            .with_file_path_and_code_and_tags(
-                biome_path.display().to_string(),
-                category!("files/missingHandler"),
-                DiagnosticTags::VERBOSE,
-            )?;
-
-        // first we stop if there are some files that don't have ALL features enabled, e.g. images, fonts, etc.
-        if file_features.is_ignored() || file_features.is_not_enabled() {
-            return Ok(FileStatus::Ignored);
-        } else if file_features.is_not_supported() {
-            return Err(Message::from(
-                UnhandledDiagnostic.with_file_path(biome_path.display().to_string()),
-            ));
-        }
-
-        // then we pick the specific features for this file
-        let unsupported_reason = match ctx.execution.traversal_mode() {
-            TraversalMode::Check { .. } | TraversalMode::CI { .. } => file_features
-                .support_kind_for(&FeatureKind::Lint)
-                .and_then(|support_kind| {
-                    if support_kind.is_not_enabled() {
-                        Some(support_kind)
-                    } else {
-                        None
-                    }
-                })
-                .and(
-                    file_features
-                        .support_kind_for(&FeatureKind::Format)
-                        .and_then(|support_kind| {
-                            if support_kind.is_not_enabled() {
-                                Some(support_kind)
-                            } else {
-                                None
-                            }
-                        }),
-                )
-                .and(
-                    file_features
-                        .support_kind_for(&FeatureKind::OrganizeImports)
-                        .and_then(|support_kind| {
-                            if support_kind.is_not_enabled() {
-                                Some(support_kind)
-                            } else {
-                                None
-                            }
-                        }),
-                ),
-            TraversalMode::Format { .. } => file_features.support_kind_for(&FeatureKind::Format),
-            TraversalMode::Lint { .. } => file_features.support_kind_for(&FeatureKind::Lint),
-            TraversalMode::Migrate { .. } => None,
-            TraversalMode::Search { .. } => file_features.support_kind_for(&FeatureKind::Search),
-        };
+    let _ = tracing::trace_span!("process_file", path = ?biome_path).entered();
+    let file_features = ctx
+        .workspace
+        .file_features(SupportsFeatureParams {
+            path: biome_path.clone(),
+            features: ctx.execution.to_feature(),
+        })
+        .with_file_path_and_code_and_tags(
+            biome_path.display().to_string(),
+            category!("files/missingHandler"),
+            DiagnosticTags::VERBOSE,
+        )?;
+
+    // first we stop if there are some files that don't have ALL features enabled, e.g. images, fonts, etc.
+    if file_features.is_ignored() || file_features.is_not_enabled() {
+        return Ok(FileStatus::Ignored);
+    } else if file_features.is_not_supported() {
+        return Err(Message::from(
+            UnhandledDiagnostic.with_file_path(biome_path.display().to_string()),
+        ));
+    }
 
-        if let Some(reason) = unsupported_reason {
-            match reason {
-                SupportKind::FileNotSupported => {
-                    return Err(Message::from(
-                        UnhandledDiagnostic.with_file_path(biome_path.display().to_string()),
-                    ));
-                }
-                SupportKind::FeatureNotEnabled | SupportKind::Ignored => {
-                    return Ok(FileStatus::Ignored);
+    // then we pick the specific features for this file
+    let unsupported_reason = match ctx.execution.traversal_mode() {
+        TraversalMode::Check { .. } | TraversalMode::CI { .. } => file_features
+            .support_kind_for(&FeatureKind::Lint)
+            .and_then(|support_kind| {
+                if support_kind.is_not_enabled() {
+                    Some(support_kind)
+                } else {
+                    None
                 }
-                SupportKind::Protected => {
-                    return Ok(FileStatus::Protected(biome_path.display().to_string()));
-                }
-                SupportKind::Supported => {}
-            };
-        }
-
-        let shared_context = &SharedTraversalOptions::new(ctx);
-
-        match ctx.execution.traversal_mode {
-            TraversalMode::Lint { .. } => {
-                // the unsupported case should be handled already at this point
-                lint(shared_context, biome_path)
-            }
-            TraversalMode::Format { .. } => {
-                // the unsupported case should be handled already at this point
-                format(shared_context, biome_path)
-            }
-            TraversalMode::Check { .. } | TraversalMode::CI { .. } => {
-                check_file(shared_context, biome_path, &file_features)
+            })
+            .and(
+                file_features
+                    .support_kind_for(&FeatureKind::Format)
+                    .and_then(|support_kind| {
+                        if support_kind.is_not_enabled() {
+                            Some(support_kind)
+                        } else {
+                            None
+                        }
+                    }),
+            )
+            .and(
+                file_features
+                    .support_kind_for(&FeatureKind::OrganizeImports)
+                    .and_then(|support_kind| {
+                        if support_kind.is_not_enabled() {
+                            Some(support_kind)
+                        } else {
+                            None
+                        }
+                    }),
+            ),
+        TraversalMode::Format { .. } => file_features.support_kind_for(&FeatureKind::Format),
+        TraversalMode::Lint { .. } => file_features.support_kind_for(&FeatureKind::Lint),
+        TraversalMode::Migrate { .. } => None,
+        TraversalMode::Search { .. } => file_features.support_kind_for(&FeatureKind::Search),
+    };
+
+    if let Some(reason) = unsupported_reason {
+        match reason {
+            SupportKind::FileNotSupported => {
+                return Err(Message::from(
+                    UnhandledDiagnostic.with_file_path(biome_path.display().to_string()),
+                ));
             }
-            TraversalMode::Migrate { .. } => {
-                unreachable!("The migration should not be called for this file")
+            SupportKind::FeatureNotEnabled | SupportKind::Ignored => {
+                return Ok(FileStatus::Ignored);
             }
-            TraversalMode::Search { ref pattern, .. } => {
-                // the unsupported case should be handled already at this point
-                search(shared_context, biome_path, pattern)
+            SupportKind::Protected => {
+                return Ok(FileStatus::Protected(biome_path.display().to_string()));
             }
+            SupportKind::Supported => {}
+        };
+    }
+
+    let shared_context = &SharedTraversalOptions::new(ctx);
+
+    match ctx.execution.traversal_mode {
+        TraversalMode::Lint { .. } => {
+            // the unsupported case should be handled already at this point
+            lint(shared_context, biome_path)
         }
-    })
+        TraversalMode::Format { .. } => {
+            // the unsupported case should be handled already at this point
+            format(shared_context, biome_path)
+        }
+        TraversalMode::Check { .. } | TraversalMode::CI { .. } => {
+            check_file(shared_context, biome_path, &file_features)
+        }
+        TraversalMode::Migrate { .. } => {
+            unreachable!("The migration should not be called for this file")
+        }
+        TraversalMode::Search { ref pattern, .. } => {
+            // the unsupported case should be handled already at this point
+            search(shared_context, biome_path, pattern)
+        }
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/assists.rs b/crates/biome_cli/src/execute/process_file/assists.rs
index 6afe2c6cf1fb..1829d746a889 100644
--- a/crates/biome_cli/src/execute/process_file/assists.rs
+++ b/crates/biome_cli/src/execute/process_file/assists.rs
@@ -15,60 +15,59 @@ pub(crate) fn assists_with_guard<'ctx>(
     ctx: &'ctx SharedTraversalOptions<'ctx, '_>,
     workspace_file: &mut WorkspaceFile,
 ) -> FileResult {
-    tracing::info_span!("Processes assists", path =? workspace_file.path.display()).in_scope(
-        move || {
-            let input = workspace_file.input()?;
-            let only = Vec::new();
-            let skip = Vec::new();
-            let fix_result = workspace_file
-                .guard()
-                .fix_file(
-                    FixFileMode::SafeFixes,
-                    false,
-                    RuleCategoriesBuilder::default().with_action().build(),
-                    only.clone(),
-                    skip.clone(),
-                )
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("assists"),
-                )?;
+    let _ =
+        tracing::info_span!("Processes assists", path =? workspace_file.path.display()).entered();
+    let input = workspace_file.input()?;
 
-            ctx.push_message(Message::SkippedFixes {
-                skipped_suggested_fixes: fix_result.skipped_suggested_fixes,
-            });
+    let only = Vec::new();
+    let skip = Vec::new();
+    let fix_result = workspace_file
+        .guard()
+        .fix_file(
+            FixFileMode::SafeFixes,
+            false,
+            RuleCategoriesBuilder::default().with_action().build(),
+            only.clone(),
+            skip.clone(),
+        )
+        .with_file_path_and_code(
+            workspace_file.path.display().to_string(),
+            category!("assists"),
+        )?;
 
-            let mut output = fix_result.code;
+    ctx.push_message(Message::SkippedFixes {
+        skipped_suggested_fixes: fix_result.skipped_suggested_fixes,
+    });
 
-            match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
-                Some(b"astro") => {
-                    output = AstroFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some(b"vue") => {
-                    output = VueFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some(b"svelte") => {
-                    output = SvelteFileHandler::output(input.as_str(), output.as_str());
-                }
-                _ => {}
-            }
-            if input != output {
-                if ctx.execution.as_fix_file_mode().is_none() {
-                    return Ok(FileStatus::Message(Message::Diff {
-                        file_name: workspace_file.path.display().to_string(),
-                        old: input,
-                        new: output,
-                        diff_kind: DiffKind::Assists,
-                    }));
-                } else {
-                    if output != input && ctx.execution.as_fix_file_mode().is_some() {
-                        workspace_file.update_file(output)?;
-                    }
-                    Ok(FileStatus::Changed)
-                }
-            } else {
-                Ok(FileStatus::Unchanged)
+    let mut output = fix_result.code;
+
+    match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
+        Some(b"astro") => {
+            output = AstroFileHandler::output(input.as_str(), output.as_str());
+        }
+        Some(b"vue") => {
+            output = VueFileHandler::output(input.as_str(), output.as_str());
+        }
+        Some(b"svelte") => {
+            output = SvelteFileHandler::output(input.as_str(), output.as_str());
+        }
+        _ => {}
+    }
+    if input != output {
+        if ctx.execution.as_fix_file_mode().is_none() {
+            return Ok(FileStatus::Message(Message::Diff {
+                file_name: workspace_file.path.display().to_string(),
+                old: input,
+                new: output,
+                diff_kind: DiffKind::Assists,
+            }));
+        } else {
+            if output != input && ctx.execution.as_fix_file_mode().is_some() {
+                workspace_file.update_file(output)?;
             }
-        },
-    )
+            Ok(FileStatus::Changed)
+        }
+    } else {
+        Ok(FileStatus::Unchanged)
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/check.rs b/crates/biome_cli/src/execute/process_file/check.rs
index 0ecea599f71c..e27a4bb27209 100644
--- a/crates/biome_cli/src/execute/process_file/check.rs
+++ b/crates/biome_cli/src/execute/process_file/check.rs
@@ -4,6 +4,9 @@ use crate::execute::process_file::lint::lint_with_guard;
 use crate::execute::process_file::organize_imports::organize_imports_with_guard;
 use crate::execute::process_file::workspace_file::WorkspaceFile;
 use crate::execute::process_file::{FileResult, FileStatus, Message, SharedTraversalOptions};
+use biome_diagnostics::{category, DiagnosticExt};
+use biome_fs::TraversalContext;
+use biome_service::diagnostics::FileTooLarge;
 use biome_service::workspace::FileFeaturesResult;
 use std::path::Path;
 
@@ -14,100 +17,106 @@ pub(crate) fn check_file<'ctx>(
 ) -> FileResult {
     let mut has_failures = false;
     let mut workspace_file = WorkspaceFile::new(ctx, path)?;
+    let result = workspace_file.guard().check_file_size()?;
+    if result.is_too_large() {
+        ctx.push_diagnostic(
+            FileTooLarge::from(result)
+                .with_file_path(path.display().to_string())
+                .with_category(category!("check")),
+        );
+        return Ok(FileStatus::Ignored);
+    }
     let mut changed = false;
-    tracing::info_span!("Process check", path =? workspace_file.path.display()).in_scope(
-        move || {
-            if file_features.supports_lint() {
-                let lint_result = lint_with_guard(ctx, &mut workspace_file);
-                match lint_result {
-                    Ok(status) => {
-                        if status.is_changed() {
-                            changed = true
-                        }
-                        if let FileStatus::Message(msg) = status {
-                            if msg.is_failure() {
-                                has_failures = true;
-                            }
-                            ctx.push_message(msg);
-                        }
-                    }
-                    Err(err) => {
-                        ctx.push_message(err);
+    let _ = tracing::info_span!("Check ", path =? workspace_file.path.display()).entered();
+    if file_features.supports_lint() {
+        let lint_result = lint_with_guard(ctx, &mut workspace_file);
+        match lint_result {
+            Ok(status) => {
+                if status.is_changed() {
+                    changed = true
+                }
+                if let FileStatus::Message(msg) = status {
+                    if msg.is_failure() {
                         has_failures = true;
                     }
+                    ctx.push_message(msg);
                 }
             }
+            Err(err) => {
+                ctx.push_message(err);
+                has_failures = true;
+            }
+        }
+    }
 
-            if file_features.supports_organize_imports() {
-                let organize_imports_result = organize_imports_with_guard(ctx, &mut workspace_file);
-                match organize_imports_result {
-                    Ok(status) => {
-                        if status.is_changed() {
-                            changed = true
-                        }
-                        if let FileStatus::Message(msg) = status {
-                            if msg.is_failure() {
-                                has_failures = true;
-                            }
-                            ctx.push_message(msg);
-                        }
-                    }
-                    Err(err) => {
-                        ctx.push_message(err);
+    if file_features.supports_organize_imports() {
+        let organize_imports_result = organize_imports_with_guard(ctx, &mut workspace_file);
+        match organize_imports_result {
+            Ok(status) => {
+                if status.is_changed() {
+                    changed = true
+                }
+                if let FileStatus::Message(msg) = status {
+                    if msg.is_failure() {
                         has_failures = true;
                     }
+                    ctx.push_message(msg);
                 }
             }
+            Err(err) => {
+                ctx.push_message(err);
+                has_failures = true;
+            }
+        }
+    }
 
-            if file_features.supports_assists() {
-                let assists_result = assists_with_guard(ctx, &mut workspace_file);
-                match assists_result {
-                    Ok(status) => {
-                        if status.is_changed() {
-                            changed = true
-                        }
-                        if let FileStatus::Message(msg) = status {
-                            if msg.is_failure() {
-                                has_failures = true;
-                            }
-                            ctx.push_message(msg);
-                        }
-                    }
-                    Err(err) => {
-                        ctx.push_message(err);
+    if file_features.supports_assists() {
+        let assists_result = assists_with_guard(ctx, &mut workspace_file);
+        match assists_result {
+            Ok(status) => {
+                if status.is_changed() {
+                    changed = true
+                }
+                if let FileStatus::Message(msg) = status {
+                    if msg.is_failure() {
                         has_failures = true;
                     }
+                    ctx.push_message(msg);
                 }
             }
+            Err(err) => {
+                ctx.push_message(err);
+                has_failures = true;
+            }
+        }
+    }
 
-            if file_features.supports_format() {
-                let format_result = format_with_guard(ctx, &mut workspace_file);
-                match format_result {
-                    Ok(status) => {
-                        if status.is_changed() {
-                            changed = true
-                        }
-                        if let FileStatus::Message(msg) = status {
-                            if msg.is_failure() {
-                                has_failures = true;
-                            }
-                            ctx.push_message(msg);
-                        }
-                    }
-                    Err(err) => {
-                        ctx.push_message(err);
+    if file_features.supports_format() {
+        let format_result = format_with_guard(ctx, &mut workspace_file);
+        match format_result {
+            Ok(status) => {
+                if status.is_changed() {
+                    changed = true
+                }
+                if let FileStatus::Message(msg) = status {
+                    if msg.is_failure() {
                         has_failures = true;
                     }
+                    ctx.push_message(msg);
                 }
             }
-
-            if has_failures {
-                Ok(FileStatus::Message(Message::Failure))
-            } else if changed {
-                Ok(FileStatus::Changed)
-            } else {
-                Ok(FileStatus::Unchanged)
+            Err(err) => {
+                ctx.push_message(err);
+                has_failures = true;
             }
-        },
-    )
+        }
+    }
+
+    if has_failures {
+        Ok(FileStatus::Message(Message::Failure))
+    } else if changed {
+        Ok(FileStatus::Changed)
+    } else {
+        Ok(FileStatus::Unchanged)
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/format.rs b/crates/biome_cli/src/execute/process_file/format.rs
index c8fe35521f70..20bce7a3448f 100644
--- a/crates/biome_cli/src/execute/process_file/format.rs
+++ b/crates/biome_cli/src/execute/process_file/format.rs
@@ -6,6 +6,8 @@ use crate::execute::process_file::{
 use crate::execute::TraversalMode;
 use biome_analyze::RuleCategoriesBuilder;
 use biome_diagnostics::{category, Diagnostic, DiagnosticExt, Error, Severity};
+use biome_fs::TraversalContext;
+use biome_service::diagnostics::FileTooLarge;
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
 use std::ffi::OsStr;
 use std::path::Path;
@@ -14,121 +16,127 @@ use tracing::debug;
 
 pub(crate) fn format<'ctx>(ctx: &'ctx SharedTraversalOptions<'ctx, '_>, path: &Path) -> FileResult {
     let mut workspace_file = WorkspaceFile::new(ctx, path)?;
-    format_with_guard(ctx, &mut workspace_file)
+    let result = workspace_file.guard().check_file_size()?;
+    if result.is_too_large() {
+        ctx.push_diagnostic(
+            FileTooLarge::from(result)
+                .with_file_path(path.display().to_string())
+                .with_category(category!("format")),
+        );
+        Ok(FileStatus::Ignored)
+    } else {
+        format_with_guard(ctx, &mut workspace_file)
+    }
 }
 
 pub(crate) fn format_with_guard<'ctx>(
     ctx: &'ctx SharedTraversalOptions<'ctx, '_>,
     workspace_file: &mut WorkspaceFile,
 ) -> FileResult {
-    tracing::info_span!("Processes formatting", path =? workspace_file.path.display()).in_scope(
-        move || {
-            let max_diagnostics = ctx.remaining_diagnostics.load(Ordering::Relaxed);
-            debug!("Pulling diagnostics from parsed file");
-            let diagnostics_result = workspace_file
-                .guard()
-                .pull_diagnostics(
-                    RuleCategoriesBuilder::default().with_syntax().build(),
-                    max_diagnostics,
-                    Vec::new(),
-                    Vec::new(),
-                )
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("format"),
-                )?;
+    let _ = tracing::info_span!("Format", path =? workspace_file.path.display()).entered();
+    let max_diagnostics = ctx.remaining_diagnostics.load(Ordering::Relaxed);
+    let diagnostics_result = workspace_file
+        .guard()
+        .pull_diagnostics(
+            RuleCategoriesBuilder::default().with_syntax().build(),
+            max_diagnostics,
+            Vec::new(),
+            Vec::new(),
+        )
+        .with_file_path_and_code(
+            workspace_file.path.display().to_string(),
+            category!("format"),
+        )?;
 
-            let input = workspace_file.input()?;
-            let (should_write, ignore_errors) = match ctx.execution.traversal_mode {
-                TraversalMode::Format {
-                    write,
-                    ignore_errors,
-                    ..
-                } => (write, ignore_errors),
+    let input = workspace_file.input()?;
+    let (should_write, ignore_errors) = match ctx.execution.traversal_mode {
+        TraversalMode::Format {
+            write,
+            ignore_errors,
+            ..
+        } => (write, ignore_errors),
 
-                _ => (
-                    ctx.execution.is_check_apply() || ctx.execution.is_check_apply_unsafe(),
-                    false,
-                ),
-            };
-            debug!("Should write the file to disk? {}", should_write);
-            debug!("Should ignore errors? {}", ignore_errors);
+        _ => (
+            ctx.execution.is_check_apply() || ctx.execution.is_check_apply_unsafe(),
+            false,
+        ),
+    };
+    debug!("Should write the file to disk? {}", should_write);
+    debug!("Should ignore errors? {}", ignore_errors);
 
-            if diagnostics_result.errors > 0 && ignore_errors {
-                return Err(Message::from(
-                    SkippedDiagnostic.with_file_path(workspace_file.path.display().to_string()),
-                ));
-            }
-
-            ctx.push_message(Message::Diagnostics {
-                name: workspace_file.path.display().to_string(),
-                content: input.clone(),
-                diagnostics: diagnostics_result
-                    .diagnostics
-                    .into_iter()
-                    .filter_map(|diag| {
-                        if diag.severity() >= Severity::Error && ignore_errors {
-                            None
-                        } else {
-                            Some(Error::from(diag))
-                        }
-                    })
-                    .collect(),
-                skipped_diagnostics: diagnostics_result.skipped_diagnostics as u32,
-            });
+    if diagnostics_result.errors > 0 && ignore_errors {
+        return Err(Message::from(
+            SkippedDiagnostic.with_file_path(workspace_file.path.display().to_string()),
+        ));
+    }
 
-            let printed = workspace_file
-                .guard()
-                .format_file()
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("format"),
-                )?;
+    ctx.push_message(Message::Diagnostics {
+        name: workspace_file.path.display().to_string(),
+        content: input.clone(),
+        diagnostics: diagnostics_result
+            .diagnostics
+            .into_iter()
+            .filter_map(|diag| {
+                if diag.severity() >= Severity::Error && ignore_errors {
+                    None
+                } else {
+                    Some(Error::from(diag))
+                }
+            })
+            .collect(),
+        skipped_diagnostics: diagnostics_result.skipped_diagnostics as u32,
+    });
 
-            let mut output = printed.into_code();
+    let printed = workspace_file
+        .guard()
+        .format_file()
+        .with_file_path_and_code(
+            workspace_file.path.display().to_string(),
+            category!("format"),
+        )?;
 
-            if ignore_errors {
-                return Ok(FileStatus::Ignored);
-            }
+    let mut output = printed.into_code();
 
-            match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
-                Some(b"astro") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = AstroFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some(b"vue") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = VueFileHandler::output(input.as_str(), output.as_str());
-                }
+    if ignore_errors {
+        return Ok(FileStatus::Ignored);
+    }
 
-                Some(b"svelte") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = SvelteFileHandler::output(input.as_str(), output.as_str());
-                }
-                _ => {}
+    match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
+        Some(b"astro") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
+            }
+            output = AstroFileHandler::output(input.as_str(), output.as_str());
+        }
+        Some(b"vue") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
             }
+            output = VueFileHandler::output(input.as_str(), output.as_str());
+        }
 
-            if output != input {
-                if should_write {
-                    workspace_file.update_file(output)?;
-                    Ok(FileStatus::Changed)
-                } else {
-                    Ok(FileStatus::Message(Message::Diff {
-                        file_name: workspace_file.path.display().to_string(),
-                        old: input,
-                        new: output,
-                        diff_kind: DiffKind::Format,
-                    }))
-                }
-            } else {
-                Ok(FileStatus::Unchanged)
+        Some(b"svelte") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
             }
-        },
-    )
+            output = SvelteFileHandler::output(input.as_str(), output.as_str());
+        }
+        _ => {}
+    }
+
+    if output != input {
+        if should_write {
+            workspace_file.update_file(output)?;
+            Ok(FileStatus::Changed)
+        } else {
+            Ok(FileStatus::Message(Message::Diff {
+                file_name: workspace_file.path.display().to_string(),
+                old: input,
+                new: output,
+                diff_kind: DiffKind::Format,
+            }))
+        }
+    } else {
+        Ok(FileStatus::Unchanged)
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/lint.rs b/crates/biome_cli/src/execute/process_file/lint.rs
index b5e4a7db823c..e2f97c9fd895 100644
--- a/crates/biome_cli/src/execute/process_file/lint.rs
+++ b/crates/biome_cli/src/execute/process_file/lint.rs
@@ -3,8 +3,10 @@ use crate::execute::process_file::workspace_file::WorkspaceFile;
 use crate::execute::process_file::{FileResult, FileStatus, Message, SharedTraversalOptions};
 use crate::TraversalMode;
 use biome_analyze::RuleCategoriesBuilder;
-use biome_diagnostics::{category, Error};
+use biome_diagnostics::{category, DiagnosticExt, Error};
+use biome_fs::TraversalContext;
 use biome_rowan::TextSize;
+use biome_service::diagnostics::FileTooLarge;
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
 use std::ffi::OsStr;
 use std::path::Path;
@@ -13,118 +15,123 @@ use std::sync::atomic::Ordering;
 /// Lints a single file and returns a [FileResult]
 pub(crate) fn lint<'ctx>(ctx: &'ctx SharedTraversalOptions<'ctx, '_>, path: &Path) -> FileResult {
     let mut workspace_file = WorkspaceFile::new(ctx, path)?;
-    lint_with_guard(ctx, &mut workspace_file)
+    let result = workspace_file.guard().check_file_size()?;
+    if result.is_too_large() {
+        ctx.push_diagnostic(
+            FileTooLarge::from(result)
+                .with_file_path(path.display().to_string())
+                .with_category(category!("lint")),
+        );
+        Ok(FileStatus::Ignored)
+    } else {
+        lint_with_guard(ctx, &mut workspace_file)
+    }
 }
 
 pub(crate) fn lint_with_guard<'ctx>(
     ctx: &'ctx SharedTraversalOptions<'ctx, '_>,
     workspace_file: &mut WorkspaceFile,
 ) -> FileResult {
-    tracing::info_span!("Processes linting", path =? workspace_file.path.display()).in_scope(
-        move || {
-            let mut input = workspace_file.input()?;
-            let mut changed = false;
-            let (only, skip) =
-                if let TraversalMode::Lint { only, skip, .. } = ctx.execution.traversal_mode() {
-                    (only.clone(), skip.clone())
-                } else {
-                    (Vec::new(), Vec::new())
-                };
-            if let Some(fix_mode) = ctx.execution.as_fix_file_mode() {
-                let fix_result = workspace_file
-                    .guard()
-                    .fix_file(
-                        *fix_mode,
-                        false,
-                        RuleCategoriesBuilder::default()
-                            .with_syntax()
-                            .with_lint()
-                            .build(),
-                        only.clone(),
-                        skip.clone(),
-                    )
-                    .with_file_path_and_code(
-                        workspace_file.path.display().to_string(),
-                        category!("lint"),
-                    )?;
+    let _ = tracing::info_span!("Lint ", path =? workspace_file.path.display()).entered();
 
-                ctx.push_message(Message::SkippedFixes {
-                    skipped_suggested_fixes: fix_result.skipped_suggested_fixes,
-                });
+    let mut input = workspace_file.input()?;
+    let mut changed = false;
+    let (only, skip) =
+        if let TraversalMode::Lint { only, skip, .. } = ctx.execution.traversal_mode() {
+            (only.clone(), skip.clone())
+        } else {
+            (Vec::new(), Vec::new())
+        };
+    if let Some(fix_mode) = ctx.execution.as_fix_file_mode() {
+        let fix_result = workspace_file
+            .guard()
+            .fix_file(
+                *fix_mode,
+                false,
+                RuleCategoriesBuilder::default()
+                    .with_syntax()
+                    .with_lint()
+                    .build(),
+                only.clone(),
+                skip.clone(),
+            )
+            .with_file_path_and_code(
+                workspace_file.path.display().to_string(),
+                category!("lint"),
+            )?;
 
-                let mut output = fix_result.code;
+        ctx.push_message(Message::SkippedFixes {
+            skipped_suggested_fixes: fix_result.skipped_suggested_fixes,
+        });
 
-                match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
-                    Some(b"astro") => {
-                        output = AstroFileHandler::output(input.as_str(), output.as_str());
-                    }
-                    Some(b"vue") => {
-                        output = VueFileHandler::output(input.as_str(), output.as_str());
-                    }
-                    Some(b"svelte") => {
-                        output = SvelteFileHandler::output(input.as_str(), output.as_str());
-                    }
-                    _ => {}
-                }
-                if output != input {
-                    changed = true;
-                    workspace_file.update_file(output)?;
-                    input = workspace_file.input()?;
-                }
+        let mut output = fix_result.code;
+
+        match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
+            Some(b"astro") => {
+                output = AstroFileHandler::output(input.as_str(), output.as_str());
+            }
+            Some(b"vue") => {
+                output = VueFileHandler::output(input.as_str(), output.as_str());
             }
+            Some(b"svelte") => {
+                output = SvelteFileHandler::output(input.as_str(), output.as_str());
+            }
+            _ => {}
+        }
+        if output != input {
+            changed = true;
+            workspace_file.update_file(output)?;
+            input = workspace_file.input()?;
+        }
+    }
 
-            let max_diagnostics = ctx.remaining_diagnostics.load(Ordering::Relaxed);
-            let pull_diagnostics_result = workspace_file
-                .guard()
-                .pull_diagnostics(
-                    RuleCategoriesBuilder::default()
-                        .with_syntax()
-                        .with_lint()
-                        .build(),
-                    max_diagnostics,
-                    only,
-                    skip,
-                )
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("lint"),
-                )?;
+    let max_diagnostics = ctx.remaining_diagnostics.load(Ordering::Relaxed);
+    let pull_diagnostics_result = workspace_file
+        .guard()
+        .pull_diagnostics(
+            RuleCategoriesBuilder::default()
+                .with_syntax()
+                .with_lint()
+                .build(),
+            max_diagnostics,
+            only,
+            skip,
+        )
+        .with_file_path_and_code(workspace_file.path.display().to_string(), category!("lint"))?;
 
-            let no_diagnostics = pull_diagnostics_result.diagnostics.is_empty()
-                && pull_diagnostics_result.skipped_diagnostics == 0;
+    let no_diagnostics = pull_diagnostics_result.diagnostics.is_empty()
+        && pull_diagnostics_result.skipped_diagnostics == 0;
 
-            if !no_diagnostics {
-                let offset = match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
-                    Some(b"vue") => VueFileHandler::start(input.as_str()),
-                    Some(b"astro") => AstroFileHandler::start(input.as_str()),
-                    Some(b"svelte") => SvelteFileHandler::start(input.as_str()),
-                    _ => None,
-                };
+    if !no_diagnostics {
+        let offset = match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
+            Some(b"vue") => VueFileHandler::start(input.as_str()),
+            Some(b"astro") => AstroFileHandler::start(input.as_str()),
+            Some(b"svelte") => SvelteFileHandler::start(input.as_str()),
+            _ => None,
+        };
 
-                ctx.push_message(Message::Diagnostics {
-                    name: workspace_file.path.display().to_string(),
-                    content: input,
-                    diagnostics: pull_diagnostics_result
-                        .diagnostics
-                        .into_iter()
-                        .map(|d| {
-                            if let Some(offset) = offset {
-                                d.with_offset(TextSize::from(offset))
-                            } else {
-                                d
-                            }
-                        })
-                        .map(Error::from)
-                        .collect(),
-                    skipped_diagnostics: pull_diagnostics_result.skipped_diagnostics as u32,
-                });
-            }
+        ctx.push_message(Message::Diagnostics {
+            name: workspace_file.path.display().to_string(),
+            content: input,
+            diagnostics: pull_diagnostics_result
+                .diagnostics
+                .into_iter()
+                .map(|d| {
+                    if let Some(offset) = offset {
+                        d.with_offset(TextSize::from(offset))
+                    } else {
+                        d
+                    }
+                })
+                .map(Error::from)
+                .collect(),
+            skipped_diagnostics: pull_diagnostics_result.skipped_diagnostics as u32,
+        });
+    }
 
-            if changed {
-                Ok(FileStatus::Changed)
-            } else {
-                Ok(FileStatus::Unchanged)
-            }
-        },
-    )
+    if changed {
+        Ok(FileStatus::Changed)
+    } else {
+        Ok(FileStatus::Unchanged)
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/organize_imports.rs b/crates/biome_cli/src/execute/process_file/organize_imports.rs
index eb2bb9902222..77d53aacc72f 100644
--- a/crates/biome_cli/src/execute/process_file/organize_imports.rs
+++ b/crates/biome_cli/src/execute/process_file/organize_imports.rs
@@ -13,57 +13,55 @@ pub(crate) fn organize_imports_with_guard<'ctx>(
     ctx: &'ctx SharedTraversalOptions<'ctx, '_>,
     workspace_file: &mut WorkspaceFile,
 ) -> FileResult {
-    tracing::info_span!("Processes import sorting", path =? workspace_file.path.display()).in_scope(
-        move || {
-            let sorted = workspace_file
-                .guard()
-                .organize_imports()
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("organizeImports"),
-                )?;
+    let _ =
+        tracing::info_span!("Sort imports for ", path =? workspace_file.path.display()).entered();
+    let sorted = workspace_file
+        .guard()
+        .organize_imports()
+        .with_file_path_and_code(
+            workspace_file.path.display().to_string(),
+            category!("organizeImports"),
+        )?;
 
-            let input = workspace_file.input()?;
-            let mut output = sorted.code;
+    let input = workspace_file.input()?;
+    let mut output = sorted.code;
 
-            match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
-                Some(b"astro") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = AstroFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some(b"vue") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = VueFileHandler::output(input.as_str(), output.as_str());
-                }
-
-                Some(b"svelte") => {
-                    if output.is_empty() {
-                        return Ok(FileStatus::Unchanged);
-                    }
-                    output = SvelteFileHandler::output(input.as_str(), output.as_str());
-                }
-                _ => {}
+    match workspace_file.as_extension().map(OsStr::as_encoded_bytes) {
+        Some(b"astro") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
+            }
+            output = AstroFileHandler::output(input.as_str(), output.as_str());
+        }
+        Some(b"vue") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
             }
+            output = VueFileHandler::output(input.as_str(), output.as_str());
+        }
 
-            if output != input {
-                if ctx.execution.is_check_apply() || ctx.execution.is_check_apply_unsafe() {
-                    workspace_file.update_file(output)?;
-                } else {
-                    return Ok(FileStatus::Message(Message::Diff {
-                        file_name: workspace_file.path.display().to_string(),
-                        old: input,
-                        new: output,
-                        diff_kind: DiffKind::OrganizeImports,
-                    }));
-                }
-                Ok(FileStatus::Changed)
-            } else {
-                Ok(FileStatus::Unchanged)
+        Some(b"svelte") => {
+            if output.is_empty() {
+                return Ok(FileStatus::Unchanged);
             }
-        },
-    )
+            output = SvelteFileHandler::output(input.as_str(), output.as_str());
+        }
+        _ => {}
+    }
+
+    if output != input {
+        if ctx.execution.is_check_apply() || ctx.execution.is_check_apply_unsafe() {
+            workspace_file.update_file(output)?;
+        } else {
+            return Ok(FileStatus::Message(Message::Diff {
+                file_name: workspace_file.path.display().to_string(),
+                old: input,
+                new: output,
+                diff_kind: DiffKind::OrganizeImports,
+            }));
+        }
+        Ok(FileStatus::Changed)
+    } else {
+        Ok(FileStatus::Unchanged)
+    }
 }
diff --git a/crates/biome_cli/src/execute/process_file/search.rs b/crates/biome_cli/src/execute/process_file/search.rs
index 8a9a7d5fb94a..16eb8d628209 100644
--- a/crates/biome_cli/src/execute/process_file/search.rs
+++ b/crates/biome_cli/src/execute/process_file/search.rs
@@ -2,6 +2,8 @@ use crate::execute::diagnostics::{ResultExt, SearchDiagnostic};
 use crate::execute::process_file::workspace_file::WorkspaceFile;
 use crate::execute::process_file::{FileResult, FileStatus, Message, SharedTraversalOptions};
 use biome_diagnostics::{category, DiagnosticExt};
+use biome_fs::TraversalContext;
+use biome_service::diagnostics::FileTooLarge;
 use biome_service::workspace::PatternId;
 use std::path::Path;
 
@@ -11,7 +13,17 @@ pub(crate) fn search<'ctx>(
     pattern: &PatternId,
 ) -> FileResult {
     let mut workspace_file = WorkspaceFile::new(ctx, path)?;
-    search_with_guard(ctx, &mut workspace_file, pattern)
+    let result = workspace_file.guard().check_file_size()?;
+    if result.is_too_large() {
+        ctx.push_diagnostic(
+            FileTooLarge::from(result)
+                .with_file_path(path.display().to_string())
+                .with_category(category!("search")),
+        );
+        Ok(FileStatus::Ignored)
+    } else {
+        search_with_guard(ctx, &mut workspace_file, pattern)
+    }
 }
 
 pub(crate) fn search_with_guard<'ctx>(
@@ -19,32 +31,29 @@ pub(crate) fn search_with_guard<'ctx>(
     workspace_file: &mut WorkspaceFile,
     pattern: &PatternId,
 ) -> FileResult {
-    tracing::info_span!("Processes searching", path =? workspace_file.path.display()).in_scope(
-        move || {
-            let result = workspace_file
-                .guard()
-                .search_pattern(pattern)
-                .with_file_path_and_code(
-                    workspace_file.path.display().to_string(),
-                    category!("search"),
-                )?;
+    let _ = tracing::info_span!("Search ", path =? workspace_file.path.display()).entered();
+    let result = workspace_file
+        .guard()
+        .search_pattern(pattern)
+        .with_file_path_and_code(
+            workspace_file.path.display().to_string(),
+            category!("search"),
+        )?;
 
-            let input = workspace_file.input()?;
-            let file_name = workspace_file.path.display().to_string();
-            let matches_len = result.matches.len();
+    let input = workspace_file.input()?;
+    let file_name = workspace_file.path.display().to_string();
+    let matches_len = result.matches.len();
 
-            let search_results = Message::Diagnostics {
-                name: file_name,
-                content: input,
-                diagnostics: result
-                    .matches
-                    .into_iter()
-                    .map(|mat| SearchDiagnostic.with_file_span(mat))
-                    .collect(),
-                skipped_diagnostics: 0,
-            };
+    let search_results = Message::Diagnostics {
+        name: file_name,
+        content: input,
+        diagnostics: result
+            .matches
+            .into_iter()
+            .map(|mat| SearchDiagnostic.with_file_span(mat))
+            .collect(),
+        skipped_diagnostics: 0,
+    };
 
-            Ok(FileStatus::SearchResult(matches_len, search_results))
-        },
-    )
+    Ok(FileStatus::SearchResult(matches_len, search_results))
 }
diff --git a/crates/biome_formatter/src/lib.rs b/crates/biome_formatter/src/lib.rs
index 0d2f343ecd7e..cc8963d1cbc4 100644
--- a/crates/biome_formatter/src/lib.rs
+++ b/crates/biome_formatter/src/lib.rs
@@ -1366,72 +1366,71 @@ pub fn format_node<L: FormatLanguage>(
     root: &SyntaxNode<L::SyntaxLanguage>,
     language: L,
 ) -> FormatResult<Formatted<L::Context>> {
-    tracing::trace_span!("format_node").in_scope(move || {
-        let (root, source_map) = match language.transform(&root.clone()) {
-            Some((transformed, source_map)) => {
-                // we don't need to insert the node back if it has the same offset
-                if &transformed == root {
-                    (transformed, Some(source_map))
-                } else {
-                    match root
-                        .ancestors()
-                        // ancestors() always returns self as the first element of the iterator.
-                        .skip(1)
-                        .last()
-                    {
-                        // current root node is the topmost node we don't need to insert the transformed node back
-                        None => (transformed, Some(source_map)),
-                        Some(top_root) => {
-                            // we have to return transformed node back into subtree
-                            let transformed_range = transformed.text_range_with_trivia();
-                            let root_range = root.text_range_with_trivia();
-
-                            let transformed_root = top_root
-                                .replace_child(root.clone().into(), transformed.into())
-                                // SAFETY: Calling `unwrap` is safe because we know that `root` is part of the `top_root` subtree.
-                                .unwrap();
-                            let transformed = transformed_root.covering_element(TextRange::new(
-                                root_range.start(),
-                                root_range.start() + transformed_range.len(),
-                            ));
-
-                            let node = match transformed {
-                                NodeOrToken::Node(node) => node,
-                                NodeOrToken::Token(token) => {
-                                    // if we get a token we need to get the parent node
-                                    token.parent().unwrap_or(transformed_root)
-                                }
-                            };
-
-                            (node, Some(source_map))
-                        }
+    let _ = tracing::trace_span!("format_node").entered();
+    let (root, source_map) = match language.transform(&root.clone()) {
+        Some((transformed, source_map)) => {
+            // we don't need to insert the node back if it has the same offset
+            if &transformed == root {
+                (transformed, Some(source_map))
+            } else {
+                match root
+                    .ancestors()
+                    // ancestors() always returns self as the first element of the iterator.
+                    .skip(1)
+                    .last()
+                {
+                    // current root node is the topmost node we don't need to insert the transformed node back
+                    None => (transformed, Some(source_map)),
+                    Some(top_root) => {
+                        // we have to return transformed node back into subtree
+                        let transformed_range = transformed.text_range_with_trivia();
+                        let root_range = root.text_range_with_trivia();
+
+                        let transformed_root = top_root
+                            .replace_child(root.clone().into(), transformed.into())
+                            // SAFETY: Calling `unwrap` is safe because we know that `root` is part of the `top_root` subtree.
+                            .unwrap();
+                        let transformed = transformed_root.covering_element(TextRange::new(
+                            root_range.start(),
+                            root_range.start() + transformed_range.len(),
+                        ));
+
+                        let node = match transformed {
+                            NodeOrToken::Node(node) => node,
+                            NodeOrToken::Token(token) => {
+                                // if we get a token we need to get the parent node
+                                token.parent().unwrap_or(transformed_root)
+                            }
+                        };
+
+                        (node, Some(source_map))
                     }
                 }
             }
-            None => (root.clone(), None),
-        };
+        }
+        None => (root.clone(), None),
+    };
 
-        let context = language.create_context(&root, source_map);
-        let format_node = FormatRefWithRule::new(&root, L::FormatRule::default());
+    let context = language.create_context(&root, source_map);
+    let format_node = FormatRefWithRule::new(&root, L::FormatRule::default());
 
-        let mut state = FormatState::new(context);
-        let mut buffer = VecBuffer::new(&mut state);
+    let mut state = FormatState::new(context);
+    let mut buffer = VecBuffer::new(&mut state);
 
-        write!(buffer, [format_node])?;
+    write!(buffer, [format_node])?;
 
-        let mut document = Document::from(buffer.into_vec());
-        document.propagate_expand();
+    let mut document = Document::from(buffer.into_vec());
+    document.propagate_expand();
 
-        state.assert_formatted_all_tokens(&root);
+    state.assert_formatted_all_tokens(&root);
 
-        let context = state.into_context();
-        let comments = context.comments();
+    let context = state.into_context();
+    let comments = context.comments();
 
-        comments.assert_checked_all_suppressions(&root);
-        comments.assert_formatted_all_comments();
+    comments.assert_checked_all_suppressions(&root);
+    comments.assert_formatted_all_comments();
 
-        Ok(Formatted::new(document, context))
-    })
+    Ok(Formatted::new(document, context))
 }
 
 /// Returns the [TextRange] for this [SyntaxElement] with the leading and
diff --git a/crates/biome_lsp/src/diagnostics.rs b/crates/biome_lsp/src/diagnostics.rs
index b1675f3624db..b446770026ff 100644
--- a/crates/biome_lsp/src/diagnostics.rs
+++ b/crates/biome_lsp/src/diagnostics.rs
@@ -54,9 +54,7 @@ pub(crate) async fn handle_lsp_error<T>(
     match err {
         LspError::WorkspaceError(err) => match err {
             // diagnostics that shouldn't raise an hard error, but send a message to the user
-            WorkspaceError::FormatWithErrorsDisabled(_)
-            | WorkspaceError::FileIgnored(_)
-            | WorkspaceError::FileTooLarge(_) => {
+            WorkspaceError::FormatWithErrorsDisabled(_) | WorkspaceError::FileIgnored(_) => {
                 let message = format!("{err}");
                 client.log_message(MessageType::WARNING, message).await;
                 Ok(None)
diff --git a/crates/biome_lsp/src/handlers/analysis.rs b/crates/biome_lsp/src/handlers/analysis.rs
index c57817562655..ccda6f8fc3bf 100644
--- a/crates/biome_lsp/src/handlers/analysis.rs
+++ b/crates/biome_lsp/src/handlers/analysis.rs
@@ -12,8 +12,8 @@ use biome_lsp_converters::line_index::LineIndex;
 use biome_rowan::{TextRange, TextSize};
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
 use biome_service::workspace::{
-    FeaturesBuilder, FixFileMode, FixFileParams, GetFileContentParams, PullActionsParams,
-    SupportsFeatureParams,
+    CheckFileSizeParams, FeaturesBuilder, FixFileMode, FixFileParams, GetFileContentParams,
+    PullActionsParams, SupportsFeatureParams,
 };
 use biome_service::WorkspaceError;
 use std::borrow::Cow;
@@ -46,7 +46,7 @@ pub(crate) fn code_actions(
     let biome_path = session.file_path(&url)?;
 
     let file_features = &session.workspace.file_features(SupportsFeatureParams {
-        path: biome_path,
+        path: biome_path.clone(),
         features: FeaturesBuilder::new()
             .with_linter()
             .with_assists()
@@ -62,6 +62,13 @@ pub(crate) fn code_actions(
         return Ok(Some(Vec::new()));
     }
 
+    let size_limit_result = session
+        .workspace
+        .check_file_size(CheckFileSizeParams { path: biome_path })?;
+    if size_limit_result.is_too_large() {
+        return Ok(None);
+    }
+
     let mut has_fix_all = false;
     let mut has_quick_fix = false;
     let mut filters = Vec::new();
@@ -258,6 +265,13 @@ fn fix_all(
             features: FeaturesBuilder::new().with_formatter().build(),
         })?
         .supports_format();
+    let size_limit_result = session.workspace.check_file_size(CheckFileSizeParams {
+        path: biome_path.clone(),
+    })?;
+    if size_limit_result.is_too_large() {
+        return Ok(None);
+    }
+
     let fixed = session.workspace.fix_file(FixFileParams {
         path: biome_path,
         fix_file_mode: FixFileMode::SafeFixes,
diff --git a/crates/biome_lsp/src/handlers/formatting.rs b/crates/biome_lsp/src/handlers/formatting.rs
index 747197958909..80a9bcecf120 100644
--- a/crates/biome_lsp/src/handlers/formatting.rs
+++ b/crates/biome_lsp/src/handlers/formatting.rs
@@ -7,14 +7,13 @@ use biome_lsp_converters::from_proto;
 use biome_rowan::{TextRange, TextSize};
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
 use biome_service::workspace::{
-    FeaturesBuilder, FileFeaturesResult, FormatFileParams, FormatOnTypeParams, FormatRangeParams,
-    GetFileContentParams, SupportsFeatureParams,
+    CheckFileSizeParams, FeaturesBuilder, FileFeaturesResult, FormatFileParams, FormatOnTypeParams,
+    FormatRangeParams, GetFileContentParams, SupportsFeatureParams,
 };
 use biome_service::{extension_error, WorkspaceError};
 use std::ffi::OsStr;
 use std::ops::Sub;
 use tower_lsp::lsp_types::*;
-use tracing::debug;
 
 #[tracing::instrument(level = "debug", skip(session), err)]
 pub(crate) fn format(
@@ -32,7 +31,13 @@ pub(crate) fn format(
     })?;
 
     if file_features.supports_format() {
-        debug!("Formatting...");
+        let size_limit_result = session.workspace.check_file_size(CheckFileSizeParams {
+            path: biome_path.clone(),
+        })?;
+        if size_limit_result.is_too_large() {
+            return Ok(None);
+        }
+
         let printed = session.workspace.format_file(FormatFileParams {
             path: biome_path.clone(),
         })?;
@@ -85,6 +90,12 @@ pub(crate) fn format_range(
     })?;
 
     if file_features.supports_format() {
+        let size_limit_result = session.workspace.check_file_size(CheckFileSizeParams {
+            path: biome_path.clone(),
+        })?;
+        if size_limit_result.is_too_large() {
+            return Ok(None);
+        }
         let doc = session.document(&url)?;
 
         let position_encoding = session.position_encoding();
@@ -157,6 +168,12 @@ pub(crate) fn format_on_type(
     })?;
 
     if file_features.supports_format() {
+        let size_limit_result = session.workspace.check_file_size(CheckFileSizeParams {
+            path: biome_path.clone(),
+        })?;
+        if size_limit_result.is_too_large() {
+            return Ok(None);
+        }
         let doc = session.document(&url)?;
 
         let position_encoding = session.position_encoding();
diff --git a/crates/biome_lsp/src/server.rs b/crates/biome_lsp/src/server.rs
index ea276fb2b8a8..20bf8967e1f8 100644
--- a/crates/biome_lsp/src/server.rs
+++ b/crates/biome_lsp/src/server.rs
@@ -621,6 +621,7 @@ impl ServerFactory {
         workspace_method!(builder, get_control_flow_graph);
         workspace_method!(builder, get_formatter_ir);
         workspace_method!(builder, change_file);
+        workspace_method!(builder, check_file_size);
         workspace_method!(builder, get_file_content);
         workspace_method!(builder, close_file);
         workspace_method!(builder, pull_diagnostics);
diff --git a/crates/biome_service/src/diagnostics.rs b/crates/biome_service/src/diagnostics.rs
index cc6f1c38e896..84855827a1ee 100644
--- a/crates/biome_service/src/diagnostics.rs
+++ b/crates/biome_service/src/diagnostics.rs
@@ -1,4 +1,4 @@
-use crate::workspace::DocumentFileSource;
+use crate::workspace::{CheckFileSizeResult, DocumentFileSource};
 use biome_analyze::RuleError;
 use biome_configuration::diagnostics::{ConfigurationDiagnostic, EditorConfigDiagnostic};
 use biome_configuration::{BiomeDiagnostic, CantLoadExtendFile};
@@ -52,8 +52,6 @@ pub enum WorkspaceError {
     TransportError(TransportError),
     /// Emitted when the file is ignored and should not be processed
     FileIgnored(FileIgnored),
-    /// Emitted when a file could not be parsed because it's larger than the size limit
-    FileTooLarge(FileTooLarge),
     /// Diagnostics emitted when querying the file system
     FileSystem(FileSystemDiagnostic),
     /// Raised when there's an issue around the VCS integration
@@ -77,10 +75,6 @@ impl WorkspaceError {
         Self::NotFound(NotFound)
     }
 
-    pub fn file_too_large(path: String, size: usize, limit: usize) -> Self {
-        Self::FileTooLarge(FileTooLarge { path, size, limit })
-    }
-
     pub fn file_ignored(path: String) -> Self {
         Self::FileIgnored(FileIgnored { path })
     }
@@ -247,34 +241,32 @@ pub struct FileIgnored {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct FileTooLarge {
-    path: String,
-    size: usize,
-    limit: usize,
+    pub size: usize,
+    pub limit: usize,
+}
+
+impl From<CheckFileSizeResult> for FileTooLarge {
+    fn from(value: CheckFileSizeResult) -> Self {
+        Self {
+            size: value.file_size,
+            limit: value.limit,
+        }
+    }
 }
 
 impl Diagnostic for FileTooLarge {
-    fn category(&self) -> Option<&'static Category> {
-        Some(category!("internalError/fs"))
+    fn severity(&self) -> Severity {
+        Severity::Information
     }
 
     fn message(&self, fmt: &mut biome_console::fmt::Formatter<'_>) -> std::io::Result<()> {
         fmt.write_markup(
             markup!{
-                "Size of "{self.path}" is "{Bytes(self.size)}" which exceeds configured maximum of "{Bytes(self.limit)}" for this project.
-                The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-                Use the `files.maxSize` configuration to change the maximum size of files processed."
+                "The size of the file is "{Bytes(self.size)}", which exceeds the configured maximum of "{Bytes(self.limit)}" for this project.
+Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file."
             }
         )
     }
-
-    fn description(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
-        write!(fmt,
-               "Size of {} is {} which exceeds configured maximum of {} for this project.\n\
-               The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.\n\
-               Use the `files.maxSize` configuration to change the maximum size of files processed.",
-               self.path, Bytes(self.size), Bytes(self.limit)
-        )
-    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -538,7 +530,7 @@ impl Advices for ProtectedFileAdvice {
 #[cfg(test)]
 mod test {
     use crate::diagnostics::{
-        CantReadDirectory, CantReadFile, DirtyWorkspace, FileIgnored, FileTooLarge, NotFound,
+        CantReadDirectory, CantReadFile, DirtyWorkspace, FileIgnored, NotFound,
         SourceFileNotSupported,
     };
     use crate::file_handlers::DocumentFileSource;
@@ -627,19 +619,6 @@ mod test {
         )
     }
 
-    #[test]
-    fn file_too_large() {
-        snap_diagnostic(
-            "file_too_large",
-            WorkspaceError::FileTooLarge(FileTooLarge {
-                path: "example.js".to_string(),
-                limit: 100,
-                size: 500,
-            })
-            .with_file_path("example.js"),
-        )
-    }
-
     #[test]
     fn transport_channel_closed() {
         snap_diagnostic(
diff --git a/crates/biome_service/src/workspace.rs b/crates/biome_service/src/workspace.rs
index 15cca63c0da2..751d57072714 100644
--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@ -594,6 +594,26 @@ pub struct GetFormatterIRParams {
 pub struct GetFileContentParams {
     pub path: BiomePath,
 }
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct CheckFileSizeParams {
+    pub path: BiomePath,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct CheckFileSizeResult {
+    pub file_size: usize,
+    pub limit: usize,
+}
+
+impl CheckFileSizeResult {
+    pub fn is_too_large(&self) -> bool {
+        self.file_size >= self.limit
+    }
+}
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -967,6 +987,12 @@ pub trait Workspace: Send + Sync + RefUnwindSafe {
     /// Return the content of a file
     fn get_file_content(&self, params: GetFileContentParams) -> Result<String, WorkspaceError>;
 
+    /// Returns `true` if the size of the file is smaller than the configured limit, `false` if equals or greater.
+    fn check_file_size(
+        &self,
+        params: CheckFileSizeParams,
+    ) -> Result<CheckFileSizeResult, WorkspaceError>;
+
     /// Change the content of an open file
     fn change_file(&self, params: ChangeFileParams) -> Result<(), WorkspaceError>;
 
@@ -1124,6 +1150,12 @@ impl<'app, W: Workspace + ?Sized> FileGuard<'app, W> {
         })
     }
 
+    pub fn check_file_size(&self) -> Result<CheckFileSizeResult, WorkspaceError> {
+        self.workspace.check_file_size(CheckFileSizeParams {
+            path: self.path.clone(),
+        })
+    }
+
     pub fn format_range(&self, range: TextRange) -> Result<Printed, WorkspaceError> {
         self.workspace.format_range(FormatRangeParams {
             path: self.path.clone(),
diff --git a/crates/biome_service/src/workspace/client.rs b/crates/biome_service/src/workspace/client.rs
index af00e2219585..82035ff49add 100644
--- a/crates/biome_service/src/workspace/client.rs
+++ b/crates/biome_service/src/workspace/client.rs
@@ -1,7 +1,8 @@
 use crate::workspace::{
-    FileFeaturesResult, GetFileContentParams, IsPathIgnoredParams, OrganizeImportsParams,
-    OrganizeImportsResult, ProjectKey, RageParams, RageResult, RegisterProjectFolderParams,
-    ServerInfo, SetManifestForProjectParams, UnregisterProjectFolderParams,
+    CheckFileSizeParams, CheckFileSizeResult, FileFeaturesResult, GetFileContentParams,
+    IsPathIgnoredParams, OrganizeImportsParams, OrganizeImportsResult, ProjectKey, RageParams,
+    RageResult, RegisterProjectFolderParams, ServerInfo, SetManifestForProjectParams,
+    UnregisterProjectFolderParams,
 };
 use crate::{TransportError, Workspace, WorkspaceError};
 use biome_formatter::Printed;
@@ -161,6 +162,13 @@ where
         self.request("biome/get_file_content", params)
     }
 
+    fn check_file_size(
+        &self,
+        params: CheckFileSizeParams,
+    ) -> Result<CheckFileSizeResult, WorkspaceError> {
+        self.request("biome/check_file_size", params)
+    }
+
     fn change_file(&self, params: ChangeFileParams) -> Result<(), WorkspaceError> {
         self.request("biome/change_file", params)
     }
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index a51caff862cd..57f2cf8cc3cd 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -1,11 +1,12 @@
 use super::{
-    ChangeFileParams, CloseFileParams, FeatureKind, FeatureName, FixFileResult, FormatFileParams,
-    FormatOnTypeParams, FormatRangeParams, GetControlFlowGraphParams, GetFormatterIRParams,
-    GetSyntaxTreeParams, GetSyntaxTreeResult, OpenFileParams, ParsePatternParams,
-    ParsePatternResult, PatternId, ProjectKey, PullActionsParams, PullActionsResult,
-    PullDiagnosticsParams, PullDiagnosticsResult, RegisterProjectFolderParams, RenameResult,
-    SearchPatternParams, SearchResults, SetManifestForProjectParams, SupportsFeatureParams,
-    UnregisterProjectFolderParams, UpdateSettingsParams,
+    ChangeFileParams, CheckFileSizeParams, CheckFileSizeResult, CloseFileParams, FeatureKind,
+    FeatureName, FixFileResult, FormatFileParams, FormatOnTypeParams, FormatRangeParams,
+    GetControlFlowGraphParams, GetFormatterIRParams, GetSyntaxTreeParams, GetSyntaxTreeResult,
+    OpenFileParams, ParsePatternParams, ParsePatternResult, PatternId, ProjectKey,
+    PullActionsParams, PullActionsResult, PullDiagnosticsParams, PullDiagnosticsResult,
+    RegisterProjectFolderParams, RenameResult, SearchPatternParams, SearchResults,
+    SetManifestForProjectParams, SupportsFeatureParams, UnregisterProjectFolderParams,
+    UpdateSettingsParams,
 };
 use crate::diagnostics::{InvalidPattern, SearchError};
 use crate::file_handlers::{
@@ -236,24 +237,7 @@ impl WorkspaceServer {
                     .parse
                     .ok_or_else(self.build_capability_error(biome_path))?;
 
-                let size_limit = {
-                    let workspace = self.workspace();
-                    let settings = workspace.settings();
-                    let limit =
-                        settings.map_or(DEFAULT_FILE_SIZE_LIMIT.get(), |s| s.files.max_size.get());
-                    usize::try_from(limit).unwrap_or(usize::MAX)
-                };
-
                 let document = &mut *document;
-                let size = document.content.as_bytes().len();
-                if size >= size_limit {
-                    return Err(WorkspaceError::file_too_large(
-                        biome_path.to_path_buf().display().to_string(),
-                        size,
-                        size_limit,
-                    ));
-                }
-
                 let workspace = self.workspace();
                 let Some(file_source) = self.get_source(document.file_source_index) else {
                     return Err(WorkspaceError::not_found());
@@ -365,6 +349,24 @@ impl WorkspaceServer {
 }
 
 impl Workspace for WorkspaceServer {
+    fn check_file_size(
+        &self,
+        params: CheckFileSizeParams,
+    ) -> Result<CheckFileSizeResult, WorkspaceError> {
+        let Some(document) = self.documents.get(&params.path) else {
+            return Err(WorkspaceError::not_found());
+        };
+        let limit = {
+            let workspace = self.workspace();
+            let settings = workspace.settings();
+            let limit = settings.map_or(DEFAULT_FILE_SIZE_LIMIT.get(), |s| s.files.max_size.get());
+            usize::try_from(limit).unwrap_or(usize::MAX)
+        };
+
+        let file_size = document.content.as_bytes().len();
+        Ok(CheckFileSizeResult { file_size, limit })
+    }
+
     fn file_features(
         &self,
         params: SupportsFeatureParams,
diff --git a/crates/biome_service/src/workspace_types.rs b/crates/biome_service/src/workspace_types.rs
index b610af8898ae..bdb2a1bbeb21 100644
--- a/crates/biome_service/src/workspace_types.rs
+++ b/crates/biome_service/src/workspace_types.rs
@@ -451,7 +451,7 @@ macro_rules! workspace_method {
 }
 
 /// Returns a list of signature for all the methods in the [Workspace] trait
-pub fn methods() -> [WorkspaceMethod; 22] {
+pub fn methods() -> [WorkspaceMethod; 23] {
     [
         workspace_method!(file_features),
         workspace_method!(update_settings),
@@ -461,6 +461,7 @@ pub fn methods() -> [WorkspaceMethod; 22] {
         workspace_method!(change_file),
         workspace_method!(close_file),
         workspace_method!(get_syntax_tree),
+        workspace_method!(check_file_size),
         workspace_method!(organize_imports),
         workspace_method!(get_file_content),
         workspace_method!(get_control_flow_graph),
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index faeb31cb8098..bf402adba217 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -2835,6 +2835,13 @@ export interface GetSyntaxTreeResult {
 	ast: string;
 	cst: string;
 }
+export interface CheckFileSizeParams {
+	path: BiomePath;
+}
+export interface CheckFileSizeResult {
+	fileSize: number;
+	limit: number;
+}
 export interface OrganizeImportsParams {
 	path: BiomePath;
 }
@@ -3520,6 +3527,7 @@ export interface Workspace {
 	changeFile(params: ChangeFileParams): Promise<void>;
 	closeFile(params: CloseFileParams): Promise<void>;
 	getSyntaxTree(params: GetSyntaxTreeParams): Promise<GetSyntaxTreeResult>;
+	checkFileSize(params: CheckFileSizeParams): Promise<CheckFileSizeResult>;
 	organizeImports(
 		params: OrganizeImportsParams,
 	): Promise<OrganizeImportsResult>;
@@ -3566,6 +3574,9 @@ export function createWorkspace(transport: Transport): Workspace {
 		getSyntaxTree(params) {
 			return transport.request("biome/get_syntax_tree", params);
 		},
+		checkFileSize(params) {
+			return transport.request("biome/check_file_size", params);
+		},
 		organizeImports(params) {
 			return transport.request("biome/organize_imports", params);
 		},


Test patch:
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large.snap b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large.snap
index ac236b9d47c5..eb132e9e8be8 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large.snap
@@ -5,9 +5,9 @@ expression: content
 # Termination Message
 
 ```block
-check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -16,46 +16,14 @@ check ━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+check.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 1.0 MiB, which exceeds the configured maximum of 1.0 MiB for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-check.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_cli_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_cli_limit.snap
index aeabc92f2481..9c642a4f4db7 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_cli_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_cli_limit.snap
@@ -12,9 +12,9 @@ statement2();
 # Termination Message
 
 ```block
-check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -23,46 +23,14 @@ check ━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+check.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-check.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_config_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_config_limit.snap
index 720c11d29ec3..fea89d3e0b9e 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_config_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/file_too_large_config_limit.snap
@@ -22,9 +22,9 @@ statement2();
 # Termination Message
 
 ```block
-check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -33,46 +33,14 @@ check ━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+check.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-check.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-check.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large.snap b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large.snap
index 81eae1591d8f..6c8aa6b76e58 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large.snap
@@ -5,9 +5,9 @@ expression: content
 # Termination Message
 
 ```block
-ci ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -16,46 +16,14 @@ ci ━━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-ci.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ci.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of ci.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 1.0 MiB, which exceeds the configured maximum of 1.0 MiB for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-ci.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_cli_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_cli_limit.snap
index 736bf0e4df5f..8c40c2609acb 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_cli_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_cli_limit.snap
@@ -12,9 +12,9 @@ statement2();
 # Termination Message
 
 ```block
-ci ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -23,46 +23,14 @@ ci ━━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-ci.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ci.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-ci.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_config_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_config_limit.snap
index 260b8b4a535e..36d24f930b54 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_config_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_ci/file_too_large_config_limit.snap
@@ -22,9 +22,9 @@ statement2();
 # Termination Message
 
 ```block
-ci ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Some errors were emitted while running checks.
+  × No files were processed in the specified paths.
   
 
 
@@ -33,46 +33,14 @@ ci ━━━━━━━━━━━━━━━━━━━━━━━━━
 # Emitted Messages
 
 ```block
-ci.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ci.js check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-ci.js organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js assists ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-ci.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Size of ci.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
-  
-
-```
-
-```block
-Checked 1 file in <TIME>. No fixes applied.
-Found 1 error.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large.snap b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large.snap
index f5b5a33ffb70..29e1de464c44 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large.snap
@@ -18,13 +18,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 format.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of format.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 1.0 MiB, which exceeds the configured maximum of 1.0 MiB for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Formatted 1 file in <TIME>. No fixes applied.
+Formatted 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_cli_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_cli_limit.snap
index c35887958fe5..4be93365ab00 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_cli_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_cli_limit.snap
@@ -25,13 +25,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 format.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of format.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Checked 1 file in <TIME>. No fixes applied.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_config_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_config_limit.snap
index 2adbe86caac6..6d10bed1ecb8 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_config_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_format/file_too_large_config_limit.snap
@@ -35,13 +35,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 format.js format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of format.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Checked 1 file in <TIME>. No fixes applied.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large.snap
index 7e8ecde29f49..4326dddb0f06 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large.snap
@@ -18,13 +18,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 1.0 MiB which exceeds configured maximum of 1.0 MiB for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 1.0 MiB, which exceeds the configured maximum of 1.0 MiB for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Checked 1 file in <TIME>. No fixes applied.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_cli_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_cli_limit.snap
index ee496ac41c89..ab9c845cc8bd 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_cli_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_cli_limit.snap
@@ -25,13 +25,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Checked 1 file in <TIME>. No fixes applied.
+Checked 0 files in <TIME>. No fixes applied.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_config_limit.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_config_limit.snap
index c78cd4e602df..d7e0a71f7eb1 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_config_limit.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/file_too_large_config_limit.snap
@@ -35,13 +35,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 check.js lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Size of check.js is 27 B which exceeds configured maximum of 16 B for this project.
-    The file size limit exists to prevent us inadvertently slowing down and loading large files that we shouldn't.
-    Use the `files.maxSize` configuration to change the maximum size of files processed.
+  i The size of the file is 27 B, which exceeds the configured maximum of 16 B for this project.
+    Use the `files.maxSize` configuration to change the maximum size of files processed, or `files.ignore` to ignore the file.
   
 
 ```
 
 ```block
-Checked 1 file in <TIME>. No fixes applied.
+Checked 0 files in <TIME>. No fixes applied.
 ```